/*      $NetBSD: label.c,v 1.52 2026/06/22 19:36:47 martin Exp $        */

/*
 * Copyright 1997 Jonathan Stone
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed for the NetBSD Project by
 *      Jonathan Stone.
 * 4. The name of Jonathan Stone may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY JONATHAN STONE ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL PIERMONT INFORMATION SYSTEMS INC. BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
__RCSID("$NetBSD: label.c,v 1.52 2026/06/22 19:36:47 martin Exp $");
#endif

#include <sys/types.h>
#include <stddef.h>
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <util.h>
#include <unistd.h>
#include <sys/dkio.h>
#include <sys/param.h>
#include <sys/bootblock.h>
#include <sys/bitops.h>
#include <ufs/ffs/fs.h>

#include "defs.h"
#include "msg_defs.h"
#include "menu_defs.h"

/*
 * local prototypes
 */
static bool boringpart(const struct disk_part_info *info);
static bool checklabel(struct disk_partitions*, char *, char *);
static void show_partition_adder(menudesc *, struct partition_usage_set*);

/*
 * Return 1 if a partition should be ignored when checking
 * for overlapping partitions.
 */
static bool
boringpart(const struct disk_part_info *info)
{

        if (info->size == 0)
                return true;
        if (info->flags & PTI_SPECIAL_PARTS)
                return true;

        return false;
}

/*
 * We have some partitions in our "wanted" list that we may not edit,
 * like the RAW_PART in disklabel, some that just represent external
 * mount entries for the final fstab or similar.
 * We have previously sorted pset->parts and pset->infos to be in sync,
 * but the former "array" may be shorter.
 * Here are a few quick predicates to check for them.
 */
static bool
real_partition(const struct partition_usage_set *pset, int index)
{
        if (index < 0 || (size_t)index >= pset->num)
                return false;

        return pset->infos[index].cur_part_id != NO_PART;
}

/*
 * Check partitioning for overlapping partitions.
 * Returns true if no overlapping partition found.
 * Sets reference arguments ovly1 and ovly2 to the indices of
 * overlapping partitions if any are found.
 */
static bool
checklabel(struct disk_partitions *parts,
    char *ovl1, char *ovl2)
{
        part_id i, j;
        struct disk_part_info info;
        daddr_t istart, iend, jstart, jend;
        unsigned int fs_type, fs_sub_type;

        if (parts->num_part == 0)
                return true;

        for (i = 0; i < parts->num_part - 1; i ++ ) {
                if (!parts->pscheme->get_part_info(parts, i, &info))
                        continue;

                /* skip unused or reserved partitions */
                if (boringpart(&info))
                        continue;

                /*
                 * check succeeding partitions for overlap.
                 * O(n^2), but n is small.
                 */
                istart = info.start;
                iend = istart + info.size;
                fs_type = info.fs_type;
                fs_sub_type = info.fs_sub_type;

                for (j = i+1; j < parts->num_part; j++) {

                        if (!parts->pscheme->get_part_info(parts, j, &info))
                                continue;

                        /* skip unused or reserved partitions */
                        if (boringpart(&info))
                                continue;

                        jstart = info.start;
                        jend = jstart + info.size;

                        /* overlap? */
                        if ((istart <= jstart && jstart < iend) ||
                            (jstart <= istart && istart < jend)) {
                                snprintf(ovl1, MENUSTRSIZE,
                                    "%" PRIu64 " - %" PRIu64 " %s, %s",
                                    istart / sizemult, iend / sizemult,
                                    multname,
                                    getfslabelname(fs_type, fs_sub_type));
                                snprintf(ovl2, MENUSTRSIZE,
                                    "%" PRIu64 " - %" PRIu64 " %s, %s",
                                    jstart / sizemult, jend / sizemult,
                                    multname,
                                    getfslabelname(info.fs_type,
                                        info.fs_sub_type));
                                return false;
                        }
                }
        }

        return true;
}

int
checkoverlap(struct disk_partitions *parts)
{
        char desc1[MENUSTRSIZE], desc2[MENUSTRSIZE];
        if (!checklabel(parts, desc1, desc2)) {
                msg_display_subst(MSG_partitions_overlap, 2, desc1, desc2);
                return 1;
        }
        return 0;
}

/*
 * return (see post_edit_verify):
 *  0 -> abort
 *  1 -> re-edit
 *  2 -> continue installation
 */
static int
verify_parts(struct partition_usage_set *pset, bool install)
{
        struct part_usage_info *wanted;
        struct disk_partitions *parts;
        size_t i, num_root;
        daddr_t first_bsdstart, inst_start;
        int rv;

        first_bsdstart = inst_start = -1;
        num_root = 0;
        parts = pset->parts;
        for (i = 0; i < pset->num; i++) {
                wanted = &pset->infos[i];

                if (wanted->flags & PUIFLG_JUST_MOUNTPOINT)
                        continue;
                if (wanted->cur_part_id == NO_PART)
                        continue;
                if (!(wanted->instflags & PUIINST_MOUNT))
                        continue;
                if (strcmp(wanted->mount, "/") != 0)
                        continue;
                num_root++;

                if (first_bsdstart <= 0) {
                        first_bsdstart = wanted->cur_start;
                }
                if (inst_start < 0 &&
                    (wanted->cur_flags & PTI_INSTALL_TARGET)) {
                        inst_start = wanted->cur_start;
                }
        }

        if ((num_root == 0 && install) ||
            (num_root > 1 && inst_start < 0)) {
                if (num_root == 0 && install)
                        msg_display_subst(MSG_must_be_one_root, 2,
                            msg_string(parts->pscheme->name),
                            msg_string(parts->pscheme->short_name));
                else
                        msg_display_subst(MSG_multbsdpart, 2,
                            msg_string(parts->pscheme->name),
                            msg_string(parts->pscheme->short_name));
                rv = ask_reedit(parts);
                if (rv != 2)
                        return rv;
        }

        /* Check for overlaps */
        if (checkoverlap(parts) != 0) {
                rv = ask_reedit(parts);
                if (rv != 2)
                        return rv;
        }

        /*
         * post_edit_verify returns:
         *  0 -> abort
         *  1 -> re-edit
         *  2 -> continue installation
         */
        if (parts->pscheme->post_edit_verify)
                return parts->pscheme->post_edit_verify(parts, false);

        return 2;
}

static int
edit_fs_start(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        daddr_t start, end;

        start = getpartoff(edit->pset->parts, edit->info.start);
        if (edit->info.size != 0) {
                if (start < (edit->info.start+edit->info.size)) {
                        /* Try to keep end in the same place */
                        end = edit->info.start + edit->info.size;
                        if (end < start)
                                edit->info.size = edit->pset->parts->pscheme->
                                    max_free_space_at(edit->pset->parts,
                                    edit->info.start);
                        else
                                edit->info.size = end - start;
                } else {
                        edit->info.size = 0;
                }
        }
        edit->info.start = start;
        return 0;
}

static int
edit_fs_size(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        struct disk_part_info pinfo;
        daddr_t size;

        /* get original partition data, in case start moved already */
        if (!edit->pset->parts->pscheme->get_part_info(edit->pset->parts,
            edit->id, &pinfo))
                pinfo = edit->info;
        /* ask for new size with old start and current values */
        size = getpartsize(edit->pset->parts, pinfo.start,
            edit->info.start, edit->info.size);
        if (size < 0)
                return 0;
        if (size > edit->pset->parts->disk_size)
                size = edit->pset->parts->disk_size - edit->info.start;
        edit->info.size = size;
        return 0;
}

static int
set_ffs_opt_pow2(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        size_t val = 1 << (edit->offset+m->cursel);

        if (edit->mode == 1) {
                edit->info.fs_opt1 = val;
                edit->wanted->fs_opt1 = val;
        } else if (edit->mode == 2) {
                edit->info.fs_opt2 = val;
                edit->wanted->fs_opt2 = val;
        }
        return 0;
}

static int
edit_fs_ffs_opt(menudesc *m, void *arg, msg head,
    size_t min_val, size_t max_val)
{
        struct single_part_fs_edit *edit = arg;
        menu_ent opts[min(MAXPHYS/4096, 8)];
        char names[min(MAXPHYS/4096, 8)][20];
        size_t i, val;
        int menu;

        edit->offset = ilog2(min_val);
        memset(opts, 0, sizeof opts);
        for (i = 0, val = min_val; val <= max_val; i++, val <<= 1) {
                snprintf(names[i], sizeof names[i], "%zu", val);
                opts[i].opt_name = names[i];
                opts[i].opt_action = set_ffs_opt_pow2;
                opts[i].opt_flags = OPT_EXIT;
        }
        menu = new_menu(head, opts, i, 40, 6, 0, 0, MC_NOEXITOPT,
            NULL, NULL, NULL, NULL, NULL);
        if (menu < 0)
                return 1;
        process_menu(menu, arg);
        free_menu(menu);
        return 0;
}

static int
edit_fs_ffs_block(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->mode = 1;         /* edit fs_opt1 */
        return edit_fs_ffs_opt(m, arg, MSG_Select_file_system_block_size,
            4096, MAXPHYS);
}

static int
edit_fs_ffs_frag(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        size_t bsize, sec_size;

        edit->mode = 2;         /* edit fs_opt2 */
        bsize = edit->info.fs_opt1;
        if (bsize == 0) {
                sec_size = edit->wanted->parts->bytes_per_sector;
                if (edit->wanted->size >= (daddr_t)(128L*(GIG/sec_size)))
                        bsize = 32*1024;
                else if (edit->wanted->size >= (daddr_t)(1000L*(MEG/sec_size)))
                        bsize = 16*1024;
                else if (edit->wanted->size >= (daddr_t)(20L*(MEG/sec_size)))
                        bsize = 8*1024;
                else
                        bsize = 4+1024;
        }
        return edit_fs_ffs_opt(m, arg, MSG_Select_file_system_fragment_size,
                bsize / 8, bsize);
}

static int
edit_fs_ffs_avg_size(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        char answer[12];

        snprintf(answer, sizeof answer, "%u", edit->info.fs_opt3);
        msg_prompt_win(MSG_ptn_isize_prompt, -1, 18, 0, 0,
                answer, answer, sizeof answer);
        edit->info.fs_opt3 = atol(answer);
        edit->wanted->fs_opt3 = edit->info.fs_opt3;

        return 0;
}

static int
edit_fs_preserve(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->wanted->instflags ^= PUIINST_NEWFS;
        return 0;
}

static int
edit_install(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->info.flags ^= PTI_INSTALL_TARGET;
        return 0;
}

static int
edit_fs_mount(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->wanted->instflags ^= PUIINST_MOUNT;
        return 0;
}

static int
edit_fs_mountpt(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        char *p, *first, *last, buf[MOUNTLEN];

        strlcpy(buf, edit->wanted->mount, sizeof buf);
        msg_prompt_win(MSG_mountpoint, -1, 18, 0, 0,
                buf, buf, MOUNTLEN);

        /*
         * Trim all leading and trailing whitespace
         */
        for (first = NULL, last = NULL, p = buf; *p; p++) {
                if (isspace((unsigned char)*p))
                        continue;
                if (first == NULL)
                        first = p;
                last = p;
        }
        if (last != NULL)
                last[1] = 0;

        if (first == NULL || *first == 0 || strcmp(first, "-") == 0) {
                edit->wanted->mount[0] = 0;
                edit->wanted->instflags &= ~PUIINST_MOUNT;
                return 0;
        }

        if (*first != '/') {
                edit->wanted->mount[0] = '/';
                strlcpy(&edit->wanted->mount[1], first,
                    sizeof(edit->wanted->mount)-1);
        } else {
                strlcpy(edit->wanted->mount, first, sizeof edit->wanted->mount);
        }
        edit->wanted->instflags |= PUIINST_MOUNT;

        return 0;
}

static int
edit_restore(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->info = edit->old_info;
        *edit->wanted = edit->old_usage;
        return 0;
}

static int
edit_cancel(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->rv = -1;
        return 1;
}

static int
edit_delete_ptn(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;

        edit->rv = -2;
        return 1;
}

/*
 * We have added/removed partitions, all cur_part_id values are
 * out of sync. Re-fetch and reorder partitions accordingly.
 */
static void
renumber_partitions(struct partition_usage_set *pset)
{
        struct part_usage_info *ninfos;
        struct disk_part_info info;
        size_t i;
        part_id pno;

        ninfos = calloc(pset->parts->num_part, sizeof(*ninfos));
        if (ninfos == NULL) {
                err_msg_win(err_outofmem);
                return;
        }

        for (pno = 0; pno < pset->parts->num_part; pno++) {
                if (!pset->parts->pscheme->get_part_info(pset->parts, pno,
                    &info))
                        continue;
                for (i = 0; i < pset->num; i++) {
                        if (pset->infos[i].cur_start != info.start)
                                continue;
                        if ((pset->infos[i].cur_flags & ~PTI_INSTALL_TARGET)
                            != (info.flags & ~PTI_INSTALL_TARGET))
                                continue;
                        if ((info.flags & PTI_SPECIAL_PARTS) !=
                            (pset->infos[i].cur_flags & PTI_SPECIAL_PARTS))
                                continue;
                        if ((info.fs_type != FS_UNUSED &&
                            info.fs_type == pset->infos[i].fs_type) ||
                            (pset->infos[i].type ==
                            info.nat_type->generic_ptype)) {
                                memcpy(&ninfos[pno], &pset->infos[i],
                                    sizeof(ninfos[pno]));
                                ninfos[pno].cur_part_id = pno;
                                break;
                        }
                }
        }

        free(pset->infos);
        pset->infos = ninfos;
        pset->num = pset->parts->num_part;
}

/*
 * Most often used file system types, we offer them in a first level menu.
 */
static const uint edit_fs_common_types[] =
    { FS_BSDFFS, FS_SWAP, FS_MSDOS, FS_EFI_SP, FS_BSDLFS, FS_EX2FS };

/*
 * Functions for uncommon file system types - we offer the full list,
 * but put FFSv2 and FFSv1 at the front and duplicate FS_MSDOS as
 * EFI system partition.
 */
static void
init_fs_type_ext(menudesc *menu, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        uint t = edit->info.fs_type;
        size_t i, ndx, max = menu->numopts;

        if (t == FS_BSDFFS) {
                if (edit->info.fs_sub_type == 3)
                        menu->cursel = 0;
                else if (edit->info.fs_sub_type == 2)
                        menu->cursel = 1;
                else
                        menu->cursel = 2;
                return;
        } else if (t == FS_EX2FS && edit->info.fs_sub_type == 1) {
                menu->cursel = FSMAXTYPES+2;
                return;
        }
        /* skip the two FFS entries, and do not add FFS later again */
        for (ndx = 3, i = 0; i < FSMAXTYPES && ndx < max; i++) {
                if (i == FS_UNUSED)
                        continue;
                if (i == FS_BSDFFS)
                        continue;
                if (fstypenames[i] == NULL)
                        continue;

                if (i == t) {
                        menu->cursel = ndx;
                        break;
                }
                if (i == FS_MSDOS) {
                        ndx++;
                        if (t == FS_EFI_SP) {
                                menu->cursel = ndx;
                                break;
                        }
                }
                ndx++;
        }
}

static int
set_fstype_ext(menudesc *menu, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        size_t i, ndx, max = menu->numopts;
        enum part_type pt;

        if (menu->cursel >= 0 && menu->cursel <= 2) {
                edit->info.fs_type = FS_BSDFFS;
                edit->info.fs_sub_type = 3-menu->cursel;
                goto found_type;
        } else if (menu->cursel == FSMAXTYPES+2) {
                edit->info.fs_type = FS_EX2FS;
                edit->info.fs_sub_type = 1;
                goto found_type;
        }

        for (ndx = 3, i = 0; i < FSMAXTYPES && ndx < max; i++) {
                if (i == FS_UNUSED)
                        continue;
                if (i == FS_BSDFFS)
                        continue;
                if (fstypenames[i] == NULL)
                        continue;

                if (ndx == (size_t)menu->cursel) {
                        edit->info.fs_type = i;
                        edit->info.fs_sub_type = 0;
                        goto found_type;
                }
                ndx++;
                if (i == FS_MSDOS) {
                        if (ndx == (size_t)menu->cursel) {
                                edit->info.fs_type = FS_EFI_SP;
                                edit->info.fs_sub_type = 0;
                                goto found_type;
                        }
                        ndx++;
                }
        }
        return 1;

found_type:
        pt = edit->info.nat_type ? edit->info.nat_type->generic_ptype : PT_root;
        edit->info.nat_type = edit->pset->parts->pscheme->
            get_fs_part_type(pt, edit->info.fs_type, edit->info.fs_sub_type);
        if (edit->info.nat_type == NULL)
                edit->info.nat_type = edit->pset->parts->pscheme->
                    get_generic_part_type(PT_root);
        edit->wanted->type = edit->info.nat_type->generic_ptype;
        edit->wanted->fs_type = edit->info.fs_type;
        edit->wanted->fs_version = edit->info.fs_sub_type;
        return 1;
}

/*
 * Offer a menu with "exotic" file system types, start with FFSv2 and FFSv1,
 * skip later FFS entry in the generic list.
 */
static int
edit_fs_type_ext(menudesc *menu, void *arg)
{
        menu_ent *opts;
        int m;
        size_t i, ndx, cnt;

        cnt = __arraycount(fstypenames)+2;
        opts = calloc(cnt, sizeof(*opts));
        if (opts == NULL)
                return 1;

        ndx = 0;
        opts[ndx].opt_name = msg_string(MSG_fs_type_ffsv2ea);
        opts[ndx].opt_action = set_fstype_ext;
        ndx++;
        opts[ndx].opt_name = msg_string(MSG_fs_type_ffsv2);
        opts[ndx].opt_action = set_fstype_ext;
        ndx++;
        opts[ndx].opt_name = msg_string(MSG_fs_type_ffs);
        opts[ndx].opt_action = set_fstype_ext;
        ndx++;
        for (i = 0; i < FSMAXTYPES && ndx < cnt; i++) {
                if (i == FS_UNUSED)
                        continue;
                if (i == FS_BSDFFS)
                        continue;
                if (fstypenames[i] == NULL)
                        continue;
                opts[ndx].opt_name = fstypenames[i];
                opts[ndx].opt_action = set_fstype_ext;
                ndx++;
                if (i == FS_MSDOS) {
                        opts[ndx] = opts[ndx-1];
                        opts[ndx].opt_name = getfslabelname(FS_EFI_SP, 0);
                        ndx++;
                }
        }
        opts[ndx].opt_name = msg_string(MSG_fs_type_ext2old);
        opts[ndx].opt_action = set_fstype_ext;
        ndx++;
        assert(ndx == cnt);
        m = new_menu(MSG_Select_the_type, opts, ndx,
                30, 6, 10, 0, MC_SUBMENU | MC_SCROLL,
                init_fs_type_ext, NULL, NULL, NULL, MSG_unchanged);

        if (m < 0)
                return 1;
        process_menu(m, arg);
        free_menu(m);
        free(opts);

        return 1;
}

static void
init_fs_type(menudesc *menu, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        size_t i;

        /* init menu->cursel from fs type in arg */
        if (edit->info.fs_type == FS_BSDFFS) {
                if (edit->info.fs_sub_type == 3)
                        menu->cursel = 0;
                else if (edit->info.fs_sub_type == 2)
                        menu->cursel = 1;
                else
                        menu->cursel = 2;
        }
        for (i = 1; i < __arraycount(edit_fs_common_types); i++) {
                if (edit->info.fs_type == edit_fs_common_types[i]) {
                        menu->cursel = i+2;
                        break;
                }
        }
}

static int
set_fstype(menudesc *menu, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        enum part_type pt;
        int ndx;

        pt = edit->info.nat_type ? edit->info.nat_type->generic_ptype : PT_root;
        if (menu->cursel < 3) {
                edit->info.fs_type = FS_BSDFFS;
                edit->info.fs_sub_type = 3-menu->cursel;
                edit->info.nat_type = edit->pset->parts->pscheme->
                    get_fs_part_type(pt, FS_BSDFFS, edit->info.fs_sub_type);
                if (edit->info.nat_type == NULL)
                        edit->info.nat_type = edit->pset->parts->
                            pscheme->get_generic_part_type(PT_root);
                edit->wanted->type = edit->info.nat_type->generic_ptype;
                edit->wanted->fs_type = edit->info.fs_type;
                edit->wanted->fs_version = edit->info.fs_sub_type;
                return 1;
        }
        ndx = menu->cursel-2;

        if (ndx < 0 ||
            (size_t)ndx >= __arraycount(edit_fs_common_types))
                return 1;

        edit->info.fs_type = edit_fs_common_types[ndx];
        edit->info.fs_sub_type = 0;
        edit->info.nat_type = edit->pset->parts->pscheme->
            get_fs_part_type(pt, edit->info.fs_type, 0);
        if (edit->info.nat_type == NULL)
                edit->info.nat_type = edit->pset->parts->
                    pscheme->get_generic_part_type(PT_root);
        edit->wanted->type = edit->info.nat_type->generic_ptype;
        edit->wanted->fs_type = edit->info.fs_type;
        edit->wanted->fs_version = edit->info.fs_sub_type;
        return 1;
}

/*
 * Offer a menu selecting the common file system types
 */
static int
edit_fs_type(menudesc *menu, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        menu_ent *opts;
        int m, cnt;
        size_t i;

        /*
         * Shortcut to full menu if we have an exotic value
         */
        if (edit->info.fs_type == FS_EX2FS && edit->info.fs_sub_type == 1) {
                edit_fs_type_ext(menu, arg);
                return 0;
        }
        for (i = 0; i < __arraycount(edit_fs_common_types); i++)
                if (edit->info.fs_type == edit_fs_common_types[i])
                        break;
        if (i >= __arraycount(edit_fs_common_types)) {
                edit_fs_type_ext(menu, arg);
                return 0;
        }

        /*
         * Starting with a common type, show short menu first
         */
        cnt = __arraycount(edit_fs_common_types) + 3;
        opts = calloc(cnt, sizeof(*opts));
        if (opts == NULL)
                return 0;

        /* special case entry 0 - 2: three FFS entries */
        for (i = 0; i < __arraycount(edit_fs_common_types); i++) {
                opts[i+2].opt_name = getfslabelname(edit_fs_common_types[i], 0);
                opts[i+2].opt_action = set_fstype;
        }
        /* duplicate FFS (at offset 2) into first two entries */
        opts[0] = opts[1] = opts[2];
        opts[0].opt_name = msg_string(MSG_fs_type_ffsv2ea);
        opts[1].opt_name = msg_string(MSG_fs_type_ffsv2);
        opts[2].opt_name = msg_string(MSG_fs_type_ffs);
        /* add secondary sub-menu */
        assert(i+2 < (size_t)cnt);
        opts[i+2].opt_name = msg_string(MSG_other_fs_type);
        opts[i+2].opt_action = edit_fs_type_ext;

        m = new_menu(MSG_Select_the_type, opts, cnt,
                30, 6, 0, 0, MC_SUBMENU | MC_SCROLL,
                init_fs_type, NULL, NULL, NULL, MSG_unchanged);

        if (m < 0)
                return 0;
        process_menu(m, arg);
        free_menu(m);
        free(opts);

        return 0;
}


static void update_edit_ptn_menu(menudesc *m, void *arg);
static void draw_edit_ptn_line(menudesc *m, int opt, void *arg);
static int edit_ptn_custom_type(menudesc *m, void *arg);

static void
remember_deleted(struct partition_usage_set *pset,
    struct disk_partitions *parts)
{
        size_t i, num;
        struct disk_partitions **tab;

        /* do we have parts on record already? */
        for (i = 0; i < pset->num_write_back; i++)
                if (pset->write_back[i] == parts)
                        return;
        /*
         * Need to record this partition table for write back
         */
        num = pset->num_write_back + 1;
        tab = realloc(pset->write_back, num*sizeof(*pset->write_back));
        if (!tab)
                return;
        tab[pset->num_write_back] = parts;
        pset->write_back = tab;
        pset->num_write_back = num;
}

int
edit_ptn(menudesc *menu, void *arg)
{
        struct partition_usage_set *pset = arg;
        struct single_part_fs_edit edit;
        int fspart_menu, num_opts;
        const char *err;
        menu_ent *mopts, *popt;
        bool is_new_part, with_inst_opt = pset->parts->parent == NULL;

        static const menu_ent edit_ptn_fields_head[] = {
                { .opt_action=edit_fs_type },
                { .opt_action=edit_fs_start },
                { .opt_action=edit_fs_size },
                { .opt_flags=OPT_IGNORE },
        };

        static const menu_ent edit_ptn_fields_head_add[] = {
                { .opt_action=edit_install },
        };

        static const menu_ent edit_ptn_fields_head2[] = {
                { .opt_action=edit_fs_preserve },
                { .opt_action=edit_fs_mount },
                { .opt_menu=MENU_mountoptions, .opt_flags=OPT_SUB },
                { .opt_action=edit_fs_mountpt },
        };

        static const menu_ent edit_ptn_fields_ffs[] = {
                { .opt_action=edit_fs_ffs_avg_size },
                { .opt_action=edit_fs_ffs_block },
                { .opt_action=edit_fs_ffs_frag },
        };

        static const menu_ent edit_ptn_fields_tail[] = {
                { .opt_name=MSG_askunits, .opt_menu=MENU_sizechoice,
                  .opt_flags=OPT_SUB },
                { .opt_name=MSG_restore,
                  .opt_action=edit_restore},
                { .opt_name=MSG_Delete_partition,
                  .opt_action=edit_delete_ptn},
                { .opt_name=MSG_cancel,
                  .opt_action=edit_cancel},
        };

        memset(&edit, 0, sizeof edit);
        edit.pset = pset;
        edit.index = menu->cursel;
        edit.wanted = &pset->infos[edit.index];

        if (menu->cursel < 0 || (size_t)menu->cursel > pset->parts->num_part)
                return 0;
        is_new_part = (size_t)menu->cursel == pset->parts->num_part;

        num_opts = __arraycount(edit_ptn_fields_head) +
            __arraycount(edit_ptn_fields_head2) +
            __arraycount(edit_ptn_fields_tail);
        if (edit.wanted->fs_type == FS_BSDFFS ||
            edit.wanted->fs_type == FS_BSDLFS)
                num_opts += __arraycount(edit_ptn_fields_ffs);
        if (with_inst_opt)
                num_opts += __arraycount(edit_ptn_fields_head_add);
        if (is_new_part)
                num_opts--;
        else
                num_opts += pset->parts->pscheme->custom_attribute_count;

        mopts = calloc(num_opts, sizeof(*mopts));
        if (mopts == NULL) {
                err_msg_win(err_outofmem);
                return 0;
        }
        memcpy(mopts, edit_ptn_fields_head, sizeof(edit_ptn_fields_head));
        popt = mopts + __arraycount(edit_ptn_fields_head);
        if (with_inst_opt) {
                memcpy(popt, edit_ptn_fields_head_add,
                    sizeof(edit_ptn_fields_head_add));
                popt +=  __arraycount(edit_ptn_fields_head_add);
        }
        memcpy(popt, edit_ptn_fields_head2, sizeof(edit_ptn_fields_head2));
        popt +=  __arraycount(edit_ptn_fields_head2);
        if (edit.wanted->fs_type == FS_BSDFFS ||
            edit.wanted->fs_type == FS_BSDLFS) {
                memcpy(popt, edit_ptn_fields_ffs, sizeof(edit_ptn_fields_ffs));
                popt +=  __arraycount(edit_ptn_fields_ffs);
        }
        edit.first_custom_attr = popt - mopts;
        if (!is_new_part) {
                for (size_t i = 0;
                    i < pset->parts->pscheme->custom_attribute_count;
                    i++, popt++) {
                        popt->opt_action = edit_ptn_custom_type;
                }
        }
        memcpy(popt, edit_ptn_fields_tail, sizeof(edit_ptn_fields_tail));
        popt += __arraycount(edit_ptn_fields_tail) - 1;
        if (is_new_part)
                memcpy(popt-1, popt, sizeof(*popt));

        if (is_new_part) {
                struct disk_part_free_space space;
                daddr_t align = pset->parts->pscheme->get_part_alignment(
                    pset->parts);

                edit.id = NO_PART;
                if (pset->parts->pscheme->get_free_spaces(pset->parts,
                    &space, 1, align, align, -1, -1) == 1) {
                        edit.info.start = space.start;
                        edit.info.size = space.size;
                        edit.info.fs_type = FS_BSDFFS;
                        edit.info.fs_sub_type = 2;
                        edit.info.nat_type = pset->parts->pscheme->
                            get_fs_part_type(PT_root, edit.info.fs_type,
                            edit.info.fs_sub_type);
                        edit.wanted->instflags = PUIINST_NEWFS;
                }
        } else {
                edit.id = pset->infos[edit.index].cur_part_id;
                if (!pset->parts->pscheme->get_part_info(pset->parts, edit.id,
                    &edit.info)) {
                        free(mopts);
                        return 0;
                }
        }

        edit.old_usage = *edit.wanted;
        edit.old_info = edit.info;

        fspart_menu = new_menu(MSG_edfspart, mopts, num_opts,
                15, 2, 0, 55, MC_NOCLEAR | MC_SCROLL,
                update_edit_ptn_menu, draw_edit_ptn_line, NULL,
                NULL, MSG_OK);

        process_menu(fspart_menu, &edit);
        free(mopts);
        free_menu(fspart_menu);

        if (edit.rv == 0) {     /* OK, set new data */
                edit.info.last_mounted = edit.wanted->mount;
                if (is_new_part) {
                        edit.wanted->parts = pset->parts;
                        if (!can_newfs_fstype(edit.info.fs_type))
                                edit.wanted->instflags &= ~PUIINST_NEWFS;
                        edit.wanted->cur_part_id = pset->parts->pscheme->
                            add_partition(pset->parts, &edit.info, &err);
                        if (edit.wanted->cur_part_id == NO_PART)
                                err_msg_win(err);
                        else {
                                pset->parts->pscheme->get_part_info(
                                    pset->parts, edit.wanted->cur_part_id,
                                    &edit.info);
                                edit.wanted->cur_start = edit.info.start;
                                edit.wanted->size = edit.info.size;
                                edit.wanted->type =
                                    edit.info.nat_type->generic_ptype;
                                edit.wanted->fs_type = edit.info.fs_type;
                                edit.wanted->fs_version = edit.info.fs_sub_type;
                                edit.wanted->cur_flags = edit.info.flags;
                                /* things have changed, re-sort */
                                renumber_partitions(pset);
                        }
                } else {
                        if (!pset->parts->pscheme->set_part_info(pset->parts,
                            edit.id, &edit.info, &err))
                                err_msg_win(err);
                        else
                                pset->cur_free_space += edit.old_info.size -
                                    edit.info.size;
                }

                /*
                 * if size has changed, we may need to add or remove
                 * the option to add partitions
                 */
                show_partition_adder(menu, pset);
        } else if (edit.rv == -1) {     /* cancel edit */
                if (is_new_part) {
                        memmove(pset->infos+edit.index,
                            pset->infos+edit.index+1,
                            sizeof(*pset->infos)*(pset->num-edit.index));
                        memmove(menu->opts+edit.index,
                            menu->opts+edit.index+1,
                            sizeof(*menu->opts)*(menu->numopts-edit.index));
                        menu->numopts--;
                        menu->cursel = 0;
                        pset->num--;
                        return -1;
                }
                pset->infos[edit.index] = edit.old_usage;
        } else if (!is_new_part && edit.rv == -2) {     /* delete partition */
                if (!pset->parts->pscheme->delete_partition(pset->parts,
                    edit.id, &err)) {
                        err_msg_win(err);
                        return 0;
                }
                remember_deleted(pset,
                    pset->infos[edit.index].parts);
                pset->cur_free_space += edit.info.size;
                memmove(pset->infos+edit.index,
                    pset->infos+edit.index+1,
                    sizeof(*pset->infos)*(pset->num-edit.index-1));
                memmove(menu->opts+edit.index,
                    menu->opts+edit.index+1,
                    sizeof(*menu->opts)*(menu->numopts-edit.index-1));
                menu->numopts--;
                menu->cursel = 0;
                if (pset->parts->num_part == 0)
                        menu->cursel = 1;       /* skip sentinel line */

                /* things have changed, re-sort */
                pset->num--;
                renumber_partitions(pset);

                /* we can likely add new partitions now */
                show_partition_adder(menu, pset);

                return -1;
        }

        return 0;
}

static void
update_edit_ptn_menu(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        int i;
        uint t = edit->info.fs_type;
        size_t attr_no;

        /* Determine which of the properties can be changed */
        for (i = 0; i < m->numopts; i++) {
                if (m->opts[i].opt_action == NULL &&
                    m->opts[i].opt_menu != MENU_mountoptions)
                        continue;

                /* Default to disabled... */
                m->opts[i].opt_flags |= OPT_IGNORE;
                if ((t == FS_UNUSED || t == FS_SWAP) &&
                    (m->opts[i].opt_action == edit_fs_preserve ||
                     m->opts[i].opt_action == edit_fs_mount ||
                     m->opts[i].opt_action == edit_fs_mountpt ||
                     m->opts[i].opt_menu == MENU_mountoptions))
                        continue;
                if (m->opts[i].opt_action == edit_install &&
                    edit->info.nat_type &&
                    edit->info.nat_type->generic_ptype != PT_root)
                        /* can only install onto PT_root partitions */
                        continue;
                if (m->opts[i].opt_action == edit_fs_preserve &&
                    !can_newfs_fstype(t)) {
                        /* Can not newfs this filesystem */
                        edit->wanted->instflags &= ~PUIINST_NEWFS;
                        continue;
                }
                if (m->opts[i].opt_action == edit_ptn_custom_type) {
                        attr_no = (size_t)i - edit->first_custom_attr;
                        if (!edit->pset->parts->pscheme->
                            custom_attribute_writable(
                            edit->pset->parts, edit->id, attr_no))
                                continue;
                }
                /*
                 * Do not allow editing of size/start/type when partition
                 * is defined in some outer partition table already
                 */
                if ((edit->pset->infos[edit->index].flags & PUIFLG_IS_OUTER)
                    && (m->opts[i].opt_action == edit_fs_type
                        || m->opts[i].opt_action == edit_fs_start
                        || m->opts[i].opt_action == edit_fs_size))
                                continue;
                /* Ok: we want this one */
                m->opts[i].opt_flags &= ~OPT_IGNORE;
        }

        /* Avoid starting at a (now) disabled menu item */
        while (m->cursel >= 0 && m->cursel < m->numopts
            && (m->opts[m->cursel].opt_flags & OPT_IGNORE))
                m->cursel++;
}

static void
draw_edit_ptn_line(menudesc *m, int opt, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        static int col_width;
        static const char *ptn_type, *ptn_start, *ptn_size, *ptn_end,
             *ptn_newfs, *ptn_mount, *ptn_mount_options, *ptn_mountpt,
             *ptn_install, *ptn_bsize, *ptn_fsize, *ptn_isize;
        const char *c;
        char val[MENUSTRSIZE];
        const char *attrname;
        size_t attr_no;

        if (col_width == 0) {
                int l;

#define LOAD(STR)       STR = msg_string(MSG_##STR); l = strlen(STR); \
                        if (l > col_width) col_width = l

                LOAD(ptn_type);
                LOAD(ptn_start);
                LOAD(ptn_size);
                LOAD(ptn_end);
                LOAD(ptn_install);
                LOAD(ptn_newfs);
                LOAD(ptn_mount);
                LOAD(ptn_mount_options);
                LOAD(ptn_mountpt);
                LOAD(ptn_bsize);
                LOAD(ptn_fsize);
                LOAD(ptn_isize);
#undef LOAD

                for (size_t i = 0;
                    i < edit->pset->parts->pscheme->custom_attribute_count;
                    i++) {
                        attrname = msg_string(
                            edit->pset->parts->pscheme->custom_attributes[i]
                            .label);
                        l = strlen(attrname);
                        if (l > col_width) col_width = l;
                }

                col_width += 3;
        }

        if (m->opts[opt].opt_flags & OPT_IGNORE
            && (opt != 3 || edit->info.fs_type == FS_UNUSED)
            && m->opts[opt].opt_action != edit_ptn_custom_type
            && m->opts[opt].opt_action != edit_fs_type
            && m->opts[opt].opt_action != edit_fs_start
            && m->opts[opt].opt_action != edit_fs_size) {
                wprintw(m->mw, "%*s -", col_width, "");
                return;
        }

        if (opt < 4) {
                switch (opt) {
                case 0:
                        if (edit->info.fs_type == FS_BSDFFS) {
                                if (edit->info.fs_sub_type == 3)
                                        c = msg_string(MSG_fs_type_ffsv2ea);
                                else if (edit->info.fs_sub_type == 2)
                                        c = msg_string(MSG_fs_type_ffsv2);
                                else
                                        c = msg_string(MSG_fs_type_ffs);
                        } else {
                                c = getfslabelname(edit->info.fs_type,
                                    edit->info.fs_sub_type);
                        }
                        wprintw(m->mw, "%*s : %s", col_width, ptn_type, c);
                        return;
                case 1:
                        wprintw(m->mw, "%*s : %" PRIu64 " %s", col_width,
                            ptn_start, edit->info.start / sizemult, multname);
                        return;
                case 2:
                        wprintw(m->mw, "%*s : %" PRIu64 " %s", col_width,
                            ptn_size, edit->info.size / sizemult, multname);
                        return;
                case 3:
                        wprintw(m->mw, "%*s : %" PRIu64 " %s", col_width,
                            ptn_end, (edit->info.start + edit->info.size)
                            / sizemult, multname);
                        return;
                 }
        }
        if (m->opts[opt].opt_action == edit_install) {
                wprintw(m->mw, "%*s : %s", col_width, ptn_install,
                        msg_string((edit->info.flags & PTI_INSTALL_TARGET)
                            ? MSG_Yes : MSG_No));
                return;
        }
        if (m->opts[opt].opt_action == edit_fs_preserve) {
                wprintw(m->mw, "%*s : %s", col_width, ptn_newfs,
                        msg_string(edit->wanted->instflags & PUIINST_NEWFS
                            ? MSG_Yes : MSG_No));
                return;
        }
        if (m->opts[opt].opt_action == edit_fs_mount) {
                wprintw(m->mw, "%*s : %s", col_width, ptn_mount,
                        msg_string(edit->wanted->instflags & PUIINST_MOUNT
                            ? MSG_Yes : MSG_No));
                return;
        }
        if (m->opts[opt].opt_action == edit_fs_ffs_block) {
                wprintw(m->mw, "%*s : %u", col_width, ptn_bsize,
                        edit->wanted->fs_opt1);
                return;
        }
        if (m->opts[opt].opt_action == edit_fs_ffs_frag) {
                wprintw(m->mw, "%*s : %u", col_width, ptn_fsize,
                        edit->wanted->fs_opt2);
                return;
        }
        if (m->opts[opt].opt_action == edit_fs_ffs_avg_size) {
                if (edit->wanted->fs_opt3 == 0)
                        wprintw(m->mw, "%*s : %s", col_width, ptn_isize,
                                msg_string(MSG_ptn_isize_dflt));
                else {
                        char buf[24], *line;
                        const char *t = buf;

                        snprintf(buf, sizeof buf, "%u", edit->wanted->fs_opt3);
                        line = str_arg_subst(msg_string(MSG_ptn_isize_bytes),
                            1, &t);
                        wprintw(m->mw, "%*s : %s", col_width, ptn_isize,
                                line);
                        free(line);
                }
                return;
        }
        if (m->opts[opt].opt_menu == MENU_mountoptions) {
                wprintw(m->mw, "%*s : ", col_width, ptn_mount_options);
                if (edit->wanted->mountflags & PUIMNT_ASYNC)
                        wprintw(m->mw, "async ");
                if (edit->wanted->mountflags & PUIMNT_NOATIME)
                        wprintw(m->mw, "noatime ");
                if (edit->wanted->mountflags & PUIMNT_NODEV)
                        wprintw(m->mw, "nodev ");
                if (edit->wanted->mountflags & PUIMNT_NODEVMTIME)
                        wprintw(m->mw, "nodevmtime ");
                if (edit->wanted->mountflags & PUIMNT_NOEXEC)
                        wprintw(m->mw, "noexec ");
                if (edit->wanted->mountflags & PUIMNT_NOSUID)
                        wprintw(m->mw, "nosuid ");
                if (edit->wanted->mountflags & PUIMNT_LOG)
                        wprintw(m->mw, "log ");
                if (edit->wanted->mountflags & PUIMNT_NOAUTO)
                        wprintw(m->mw, "noauto  ");
                return;
        }
        if (m->opts[opt].opt_action == edit_fs_mountpt) {
                wprintw(m->mw, "%*s : %s", col_width, ptn_mountpt,
                    edit->wanted->mount);
                return;
        }

        attr_no = opt - edit->first_custom_attr;
        edit->pset->parts->pscheme->format_custom_attribute(
            edit->pset->parts, edit->id, attr_no, &edit->info,
            val, sizeof val);
        attrname = msg_string(edit->pset->parts->pscheme->
            custom_attributes[attr_no].label);
        wprintw(m->mw, "%*s : %s", col_width, attrname, val);
}

static int
edit_ptn_custom_type(menudesc *m, void *arg)
{
        struct single_part_fs_edit *edit = arg;
        size_t attr_no = m->cursel - edit->first_custom_attr;
        char line[STRSIZE];

        switch (edit->pset->parts->pscheme->custom_attributes[attr_no].type) {
        case pet_bool:
                edit->pset->parts->pscheme->custom_attribute_toggle(
                    edit->pset->parts, edit->id, attr_no);
                break;
        case pet_cardinal:
        case pet_str:
                edit->pset->parts->pscheme->format_custom_attribute(
                    edit->pset->parts, edit->id, attr_no, &edit->info,
                    line, sizeof(line));
                msg_prompt_win(
                    edit->pset->parts->pscheme->custom_attributes[attr_no].
                    label, -1, 18, 0, 0, line, line, sizeof(line));
                edit->pset->parts->pscheme->custom_attribute_set_str(
                    edit->pset->parts, edit->id, attr_no, line);
                break;
        }

        return 0;
}


/*
 * Some column width depend on translation, we will set these in
 * fmt_fspart_header and later use it when formatting single entries
 * in fmt_fspart_row.
 * The table consist of 3 "size like" columns, all fixed width, then
 * ptnheaders_fstype, part_header_col_flag, and finally the mount point
 * (which is variable width).
 */
static int fstype_width, flags_width;
static char fspart_separator[MENUSTRSIZE];
static char fspart_title[2*MENUSTRSIZE];

/*
 * Format the header of the main partition editor menu.
 */
static void
fmt_fspart_header(menudesc *menu, void *arg)
{
        struct partition_usage_set *pset = arg;
        char total[6], free_space[6], scol[13], ecol[13], szcol[13],
            sepline[MENUSTRSIZE], *p, desc[MENUSTRSIZE];
        const char *fstype, *flags;
        int i;
        size_t ptn;
        bool with_clone, with_inst_flag = pset->parts->parent == NULL;

        with_clone = false;
        for (ptn = 0; ptn < pset->num && !with_clone; ptn++)
                if (pset->infos[ptn].flags & PUIFLG_CLONE_PARTS)
                        with_clone = true;
        humanize_number(total, sizeof total,
            pset->parts->disk_size * pset->parts->bytes_per_sector,
            "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
        humanize_number(free_space, sizeof free_space,
            pset->cur_free_space * pset->parts->bytes_per_sector,
            "", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);

        if (with_clone)
                strlcpy(desc, msg_string(MSG_clone_flag_desc), sizeof desc);
        else
                desc[0] = 0;
        if (pset->parts->pscheme->part_flag_desc)
                strlcat(desc, msg_string(pset->parts->pscheme->part_flag_desc),
                sizeof desc);

        msg_display_subst(MSG_fspart, 7, pset->parts->disk,
            msg_string(pset->parts->pscheme->name),
            msg_string(pset->parts->pscheme->short_name),
            with_inst_flag ? msg_string(MSG_ptn_instflag_desc) : "",
            desc, total, free_space);

        snprintf(scol, sizeof scol, "%s (%s)",
            msg_string(MSG_ptnheaders_start), multname);
        snprintf(ecol, sizeof ecol, "%s (%s)",
            msg_string(MSG_ptnheaders_end), multname);
        snprintf(szcol, sizeof szcol, "%s (%s)",
            msg_string(MSG_ptnheaders_size), multname);

        fstype = msg_string(MSG_ptnheaders_fstype);
        flags = msg_string(MSG_part_header_col_flag);
        fstype_width = max(strlen(fstype), 8);
        flags_width = strlen(flags);
        for (i = 0, p = sepline; i < fstype_width; i++)
                *p++ = '-';
        for (i = 0, *p++ = ' '; i < flags_width; i++)
                *p++ = '-';
        *p = 0;

        snprintf(fspart_separator, sizeof(fspart_separator),
            "------------ ------------ ------------ %s ----------------",
            sepline);

        snprintf(fspart_title, sizeof(fspart_title),
            "   %12.12s %12.12s %12.12s %*s %*s %s\n"
            "   %s", scol, ecol, szcol, fstype_width, fstype,
            flags_width, flags, msg_string(MSG_ptnheaders_filesystem),
            fspart_separator);

        msg_table_add("\n\n");
}

/*
 * Format one partition entry in the main partition editor.
 */
static void
fmt_fspart_row(menudesc *m, int ptn, void *arg)
{
        struct partition_usage_set *pset = arg;
        struct disk_part_info info;
        daddr_t poffset, psize, pend;
        const char *desc;
        static const char *Yes;
        char flag_str[MENUSTRSIZE], *fp;
        unsigned inst_flags;
#ifndef NO_CLONES
        size_t clone_cnt;
#endif
        bool with_inst_flag = pset->parts->parent == NULL;

        if (Yes == NULL)
                Yes = msg_string(MSG_Yes);

#ifndef NO_CLONES
        if ((pset->infos[ptn].flags & PUIFLG_CLONE_PARTS) &&
           pset->infos[ptn].cur_part_id == NO_PART) {
                psize = pset->infos[ptn].size / sizemult;
                if (pset->infos[ptn].clone_ndx <
                    pset->infos[ptn].clone_src->num_sel)
                        clone_cnt = 1;
                else
                        clone_cnt = pset->infos[ptn].clone_src->num_sel;
                if (pset->infos[ptn].cur_part_id == NO_PART)
                        wprintw(m->mw, "                          %12" PRIu64
                            " [%zu %s]", psize, clone_cnt,
                            msg_string(MSG_clone_target_disp));
                else {
                        poffset = pset->infos[ptn].cur_start / sizemult;
                        pend = (pset->infos[ptn].cur_start +
                            pset->infos[ptn].size) / sizemult - 1;
                        wprintw(m->mw, "%12" PRIu64 " %12" PRIu64 " %12" PRIu64
                            " [%zu %s]",
                            poffset, pend, psize, clone_cnt,
                            msg_string(MSG_clone_target_disp));
                }
                if (m->title == fspart_title)
                        m->opts[ptn].opt_flags |= OPT_IGNORE;
                else
                        m->opts[ptn].opt_flags &= ~OPT_IGNORE;
                return;
        }
#endif

        if (!real_partition(pset, ptn))
                return;

        if (!pset->parts->pscheme->get_part_info(pset->parts,
            pset->infos[ptn].cur_part_id, &info))
                return;

        /*
         * We use this function in multiple menus, but only want it
         * to play with enable/disable in a single one:
         */
        if (m->title == fspart_title) {
                /*
                 * Enable / disable this line if it is something
                 * like RAW_PART
                 */
                if ((info.flags &
                    (PTI_WHOLE_DISK|PTI_PSCHEME_INTERNAL|PTI_RAW_PART))
                    || (pset->infos[ptn].flags & PUIFLG_CLONE_PARTS))
                        m->opts[ptn].opt_flags |= OPT_IGNORE;
                else
                        m->opts[ptn].opt_flags &= ~OPT_IGNORE;
        }

        poffset = info.start / sizemult;
        psize = info.size / sizemult;
        if (psize == 0)
                pend = 0;
        else
                pend = (info.start + info.size) / sizemult - 1;

        if (info.flags & PTI_WHOLE_DISK)
                desc = msg_string(MSG_NetBSD_partition_cant_change);
        else if (info.flags & PTI_RAW_PART)
                desc = msg_string(MSG_Whole_disk_cant_change);
        else if (info.flags & PTI_BOOT)
                desc = msg_string(MSG_Boot_partition_cant_change);
        else
                desc = getfslabelname(info.fs_type, info.fs_sub_type);

        fp = flag_str;
        inst_flags = pset->infos[ptn].instflags;
        if (with_inst_flag && (info.flags & PTI_INSTALL_TARGET) &&
            info.nat_type->generic_ptype == PT_root) {
                static char inst_flag;

                if (inst_flag == 0)
                        inst_flag = msg_string(MSG_install_flag)[0];
                *fp++ = inst_flag;
        }
        if (inst_flags & PUIINST_NEWFS)
                *fp++ = msg_string(MSG_newfs_flag)[0];
        if (pset->infos[ptn].flags & PUIFLG_CLONE_PARTS)
                *fp++ = msg_string(MSG_clone_flag)[0];
        *fp = 0;
        if (pset->parts->pscheme->get_part_attr_str != NULL)
                pset->parts->pscheme->get_part_attr_str(pset->parts,
                    pset->infos[ptn].cur_part_id, fp,
                    sizeof(flag_str)-1-(fp-flag_str));

        /* if the fstype description does not fit, check if we can overrun */
        if (strlen(desc) > (size_t)fstype_width &&
             flag_str[0] == 0 && (info.last_mounted == NULL ||
             info.last_mounted[0] == 0))
                wprintw(m->mw, "%12" PRIu64 " %12" PRIu64 " %12" PRIu64
                    " %s",
                    poffset, pend, psize, desc);
        else
                wprintw(m->mw, "%12" PRIu64 " %12" PRIu64 " %12" PRIu64
                    " %*.*s %*s %s",
                    poffset, pend, psize, fstype_width, fstype_width, desc,
                    -flags_width, flag_str,
                    (inst_flags & PUIINST_MOUNT) && info.last_mounted &&
                     info.last_mounted[0] ? info.last_mounted : "");
}

#ifndef NO_CLONES
static int
part_ext_clone(menudesc *m, void *arg)
{
        struct selected_partitions selected, *clone_src;
        struct clone_target_menu_data data;
        struct partition_usage_set *pset = arg;
        struct part_usage_info *p;
        struct disk_part_info sinfo, cinfo;
        struct disk_partitions *csrc;
        struct disk_part_free_space space;
        menu_ent *men;
        daddr_t clone_size, free_size, offset, align;
        int num_men, i;
        size_t s, clone_cnt;
        part_id cid;
        struct clone_data {
                struct disk_part_info info;
                part_id new_id;
                size_t ndx;
        };
        struct clone_data *clones = NULL;

        if (!select_partitions(&selected, pm->parts))
                return 0;

        clone_size = selected_parts_size(&selected);
        num_men = pset->num+1;
        men = calloc(num_men, sizeof *men);
        if (men == NULL)
                return 0;
        for (i = 0; i < num_men; i++) {
                men[i].opt_action = clone_target_select;
                if (i == 0)
                        free_size = pset->infos[i].cur_start;
                else if (i > 0 && (size_t)i < pset->num)
                        free_size = pset->infos[i].cur_start -
                            pset->infos[i-1].cur_start - pset->infos[i-1].size;
                else
                        free_size = pset->parts->free_space;
                if (free_size < clone_size)
                        men[i].opt_flags = OPT_IGNORE;
        }
        men[num_men-1].opt_name = MSG_clone_target_end;

        memset(&data, 0, sizeof data);
        data.usage = *pset;
        data.res = -1;

        data.usage.menu = new_menu(MSG_clone_target_hdr,
            men, num_men, 3, 2, 0, 65, MC_SCROLL,
            NULL, fmt_fspart_row, NULL, NULL, MSG_cancel);
        process_menu(data.usage.menu, &data);
        free_menu(data.usage.menu);
        free(men);

        if (data.res < 0)
                goto err;

        /* create temporary infos for all clones that work out */
        clone_cnt = 0;
        clones = calloc(selected.num_sel, sizeof(*clones));
        if (clones == NULL)
                goto err;

        clone_src = malloc(sizeof(selected));
        if (clone_src == NULL)
                goto err;
        *clone_src = selected;

        /* find selected offset from data.res and insert clones there */
        align = pset->parts->pscheme->get_part_alignment(pset->parts);
        offset = -1;
        if (data.res > 0)
                offset = pset->infos[data.res-1].cur_start
                    + pset->infos[data.res-1].size;
        else
                offset = 0;
        for (s = 0; s < selected.num_sel; s++) {
                csrc = selected.selection[s].parts;
                cid = selected.selection[s].id;
                csrc->pscheme->get_part_info(csrc, cid, &sinfo);
                if (!pset->parts->pscheme->adapt_foreign_part_info(
                    pset->parts, &cinfo, csrc->pscheme, &sinfo))
                        continue;
                size_t cnt = pset->parts->pscheme->get_free_spaces(
                    pset->parts, &space, 1, cinfo.size-align, align,
                    offset, -1);
                if (cnt == 0)
                        continue;
                cinfo.start = space.start;
                cid = pset->parts->pscheme->add_partition(
                    pset->parts, &cinfo, NULL);
                if (cid == NO_PART)
                        continue;
                pset->parts->pscheme->get_part_info(pset->parts, cid, &cinfo);
                clones[clone_cnt].info = cinfo;
                clones[clone_cnt].new_id = cid;
                clones[clone_cnt].ndx = s;
                clone_cnt++;
                offset = roundup(cinfo.start+cinfo.size, align);
        }

        /* insert new clone records at offset data.res */
        men = realloc(m->opts, (m->numopts+clone_cnt)*sizeof(*m->opts));
        if (men == NULL)
                goto err;
        pset->menu_opts = men;
        m->opts = men;
        m->numopts += clone_cnt;

        p = realloc(pset->infos, (pset->num+clone_cnt)*sizeof(*pset->infos));
        if (p == NULL)
                goto err;
        pset->infos = p;

        men += data.res;
        p += data.res;
        memmove(men+clone_cnt, men,
            sizeof(*men)*(m->numopts-data.res-clone_cnt));
        if (pset->num > (size_t)data.res)
                memmove(p+clone_cnt, p, sizeof(*p)*(pset->num-data.res));
        memset(men, 0, sizeof(*men)*clone_cnt);
        memset(p, 0, sizeof(*p)*clone_cnt);
        for (s = 0; s < clone_cnt; s++) {
                p[s].cur_part_id = clones[s].new_id;
                p[s].cur_start = clones[s].info.start;
                p[s].size = clones[s].info.size;
                p[s].cur_flags = clones[s].info.flags;
                p[s].flags = PUIFLG_CLONE_PARTS;
                p[s].parts = pset->parts;
                p[s].clone_src = clone_src;
                p[s].clone_ndx = s;
        }
        free(clones);
        m->cursel = ((size_t)data.res >= pset->num) ? 0 : data.res+clone_cnt;
        pset->num += clone_cnt;
        m->h = 0;
        resize_menu_height(m);

        return -1;

err:
        free(clones);
        free_selected_partitions(&selected);
        return 0;
}
#endif

static int
edit_fspart_pack(menudesc *m, void *arg)
{
        struct partition_usage_set *pset = arg;
        char buf[STRSIZE];

        if (!pset->parts->pscheme->get_disk_pack_name(pset->parts,
            buf, sizeof buf))
                return 0;

        msg_prompt_win(MSG_edit_disk_pack_hdr,
            -1, 18, 0, -1, buf, buf, sizeof(buf));

        pset->parts->pscheme->set_disk_pack_name(pset->parts, buf);
        return 0;
}

static int
edit_fspart_add(menudesc *m, void *arg)
{
        struct partition_usage_set *pset = arg;
        struct part_usage_info *ninfo;
        menu_ent *nmenopts;
        size_t cnt, off;

        ninfo = realloc(pset->infos, (pset->num+1)*sizeof(*pset->infos));
        if (ninfo == NULL)
                return 0;
        pset->infos = ninfo;
        off = pset->parts->num_part;
        cnt = pset->num-pset->parts->num_part;
        if (cnt > 0)
                memmove(pset->infos+off+1,pset->infos+off,
                    cnt*sizeof(*pset->infos));
        memset(pset->infos+off, 0, sizeof(*pset->infos));

        nmenopts = realloc(m->opts, (m->numopts+1)*sizeof(*m->opts));
        if (nmenopts == NULL)
                return 0;
        memmove(nmenopts+off+1, nmenopts+off,
            (m->numopts-off)*sizeof(*nmenopts));
        memset(&nmenopts[off], 0, sizeof(nmenopts[off]));
        nmenopts[off].opt_action = edit_ptn;
        pset->menu_opts = m->opts = nmenopts;
        m->numopts++;
        m->cursel = off;
        pset->num++;

        /* now update edit menu to fit */
        m->h = 0;
        resize_menu_height(m);

        /* and directly invoke the partition editor for the new part */
        edit_ptn(m, arg);

        show_partition_adder(m, pset);

        return -1;
}

static void
add_partition_adder(menudesc *m, struct partition_usage_set *pset)
{
        struct part_usage_info *ninfo;
        menu_ent *nmenopts;
        size_t off;

        ninfo = realloc(pset->infos, (pset->num+1)*sizeof(*pset->infos));
        if (ninfo == NULL)
                return;
        pset->infos = ninfo;
        off = pset->parts->num_part+1;

        nmenopts = realloc(m->opts, (m->numopts+1)*sizeof(*m->opts));
        if (nmenopts == NULL)
                return;
        memmove(nmenopts+off+1, nmenopts+off,
            (m->numopts-off)*sizeof(*nmenopts));
        memset(&nmenopts[off], 0, sizeof(nmenopts[off]));

        nmenopts[off].opt_name = MSG_addpart;
        nmenopts[off].opt_flags = OPT_SUB;
        nmenopts[off].opt_action = edit_fspart_add;

        m->opts = nmenopts;
        m->numopts++;
}

static void
remove_partition_adder(menudesc *m, struct partition_usage_set *pset)
{
        size_t off;

        off = pset->parts->num_part+1;
        memmove(m->opts+off, m->opts+off+1,
            (m->numopts-off-1)*sizeof(*m->opts));
        m->numopts--;
}

/*
 * Called whenever the "add a partition" option may need to be removed
 * or added
 */
static void
show_partition_adder(menudesc *m, struct partition_usage_set *pset)
{
        if (m->opts == NULL)
                return;

        bool can_add_partition = pset->parts->pscheme->can_add_partition(
            pset->parts);
        bool part_adder_present =
            (m->opts[pset->parts->num_part].opt_flags & OPT_IGNORE) &&
            (m->opts[pset->parts->num_part+1].opt_action == edit_fspart_add);

        if (can_add_partition == part_adder_present)
                return;

        if (can_add_partition)
                add_partition_adder(m, pset);
        else
                remove_partition_adder(m, pset);

        /* now update edit menu to fit */
        m->h = 0;
        resize_menu_height(m);
}

static int
edit_fspart_abort(menudesc *m, void *arg)
{
        struct partition_usage_set *pset = arg;

        pset->ok = false;
        return 1;
}

/*
 * Check a disklabel.
 * If there are overlapping active partitions,
 * Ask the user if they want to edit the partition or give up.
 */
int
edit_and_check_label(struct pm_devs *p, struct partition_usage_set *pset,
    bool install)
{
        menu_ent *op;
        size_t cnt, i;
        bool may_add = pset->parts->pscheme->can_add_partition(pset->parts);
        bool may_edit_pack =
            pset->parts->pscheme->get_disk_pack_name != NULL &&
            pset->parts->pscheme->set_disk_pack_name != NULL;

#ifdef NO_CLONES
#define C_M_ITEMS       0
#else
#define C_M_ITEMS       1
#endif
        pset->menu_opts = calloc(pset->parts->num_part
             +3+C_M_ITEMS+may_add+may_edit_pack,
             sizeof *pset->menu_opts);
        if (pset->menu_opts == NULL)
                return 0;

        op = pset->menu_opts;
        for (i = 0; i < pset->parts->num_part; i++) {
                op->opt_action = edit_ptn;
                op++;
        }
        /* separator line between partitions and actions */
        op->opt_name = fspart_separator;
        op->opt_flags = OPT_IGNORE|OPT_NOSHORT;
        op++;

        /* followed by new partition adder */
        if (may_add) {
                op->opt_name = MSG_addpart;
                op->opt_flags = OPT_SUB;
                op->opt_action = edit_fspart_add;
                op++;
        }

        /* and unit changer */
        op->opt_name = MSG_askunits;
        op->opt_menu = MENU_sizechoice;
        op->opt_flags = OPT_SUB;
        op->opt_action = NULL;
        op++;

        if (may_edit_pack) {
                op->opt_name = MSG_editpack;
                op->opt_flags = OPT_SUB;
                op->opt_action = edit_fspart_pack;
                op++;
        }

#ifndef NO_CLONES
        /* add a clone-from-elsewhere option */
        op->opt_name = MSG_clone_from_elsewhere;
        op->opt_action = part_ext_clone;
        op++;
#endif

        /* and abort option */
        op->opt_name = MSG_cancel;
        op->opt_flags = OPT_EXIT;
        op->opt_action = edit_fspart_abort;
        op++;
        cnt = op - pset->menu_opts;
        assert(cnt == pset->parts->num_part+3+C_M_ITEMS+may_add+may_edit_pack);

        pset->menu = new_menu(fspart_title, pset->menu_opts, cnt,
                        0, -1, 0, 74,
                        MC_ALWAYS_SCROLL|MC_NOBOX|MC_DFLTEXIT|
                        MC_NOCLEAR|MC_CONTINUOUS,
                        fmt_fspart_header, fmt_fspart_row, NULL, NULL,
                        MSG_partition_sizes_ok);

        if (pset->menu < 0) {
                free(pset->menu_opts);
                pset->menu_opts = NULL;
                return 0;
        }

        p->current_cylsize = p->dlcylsize;

        for (;;) {
                /* first give the user the option to edit the label... */
                pset->ok = true;
                process_menu(pset->menu, pset);
                if (!pset->ok) {
                        i = 0;
                        break;
                }

                /* User thinks the label is OK. */
                i = verify_parts(pset, install);
                if (i == 1)
                        continue;
                break;
        }
        free(pset->menu_opts);
        pset->menu_opts = NULL;
        free_menu(pset->menu);
        pset->menu = -1;

        return i != 0;
}

/*
 * strip trailing / to avoid confusion in path comparisons later
 */
void
canonicalize_last_mounted(char *path)
{
        char *p;

        if (path == NULL)
                return;

        if (strcmp(path, "/") == 0)
                return; /* in this case a "trailing" slash is allowed */

        for (;;) {
                p = strrchr(path, '/');
                if (p == NULL)
                        return;
                if (p[1] != 0)
                        return;
                p[0] = 0;
        }
}

/*
 * Try to get 'last mounted on' (or equiv) from fs superblock.
 */
const char *
get_last_mounted(int fd, daddr_t partstart, uint *fs_type, uint *fs_sub_type,
    uint flags)
{
        static char sblk[SBLOCKSIZE] __aligned(8);      /* is this enough? */
        struct fs *SB = (struct fs *)sblk;
        static const off_t sblocks[] = SBLOCKSEARCH;
        const off_t *sbp;
        const char *mnt = NULL;
        int len;

        if (fd == -1)
                return "";

        if (fs_type)
                *fs_type = 0;
        if (fs_sub_type)
                *fs_sub_type = 0;

        /* Check UFS1/2 (and hence LFS) superblock */
        for (sbp = sblocks; mnt == NULL && *sbp != -1; sbp++) {
                if (pread(fd, sblk, sizeof sblk,
                    (off_t)partstart * (off_t)512 + *sbp) != sizeof sblk)
                        continue;

                /*
                 * If start of partition and allowed by flags check
                 * for other fs types
                 */
                if (*sbp == 0 && (flags & GLM_MAYBE_FAT32) &&
                    sblk[0x42] == 0x29 && memcmp(sblk + 0x52, "FAT", 3) == 0) {
                        /* Probably a FAT filesystem, report volume name */
                        size_t i;
                        for (i = 0x51; i >= 0x47; i--) {
                                if (sblk[i] != ' ')
                                        break;
                                sblk[i] = 0;
                        }
                        sblk[0x52] = 0;
                        if (fs_type)
                                *fs_type = FS_MSDOS;
                        if (fs_sub_type)
                                *fs_sub_type = sblk[0x53];
                        return sblk + 0x47;
                } else if (*sbp == 0 && (flags & GLM_MAYBE_NTFS) &&
                    memcmp(sblk+3, "NTFS    ", 8) == 0) {
                        if (fs_type)
                                *fs_type = FS_NTFS;
                        if (fs_sub_type)
                                *fs_sub_type = MBR_PTYPE_NTFS;
                        /* XXX dig for volume name attribute ? */
                        return "";
                }

                if (!(flags & GLM_LIKELY_FFS))
                        continue;

                /* Maybe we should validate the checksum??? */
                switch (SB->fs_magic) {
                case FS_UFS1_MAGIC:
                case FS_UFS1_MAGIC_SWAPPED:
                        if (!(SB->fs_old_flags & FS_FLAGS_UPDATED)) {
                                if (*sbp == SBLOCK_UFS1)
                                        mnt = (const char *)SB->fs_fsmnt;
                        } else {
                                /* Check we have the main superblock */
                                if (SB->fs_sblockloc == *sbp)
                                        mnt = (const char *)SB->fs_fsmnt;
                        }
                        if (fs_type)
                                *fs_type = FS_BSDFFS;
                        if (fs_sub_type)
                                *fs_sub_type = 1;
                        continue;
                case FS_UFS2_MAGIC:
                case FS_UFS2EA_MAGIC:
                case FS_UFS2_MAGIC_SWAPPED:
                case FS_UFS2EA_MAGIC_SWAPPED:
                        /* Check we have the main superblock */
                        if (SB->fs_sblockloc == *sbp) {
                                mnt = (const char *)SB->fs_fsmnt;
                                if (fs_type)
                                        *fs_type = FS_BSDFFS;
                                if (fs_sub_type)
                                        *fs_sub_type = 2;
                        }
                        continue;
                }
        }

        if (mnt == NULL)
                return "";

        /* If sysinst mounted this last then strip prefix */
        len = strlen(targetroot_mnt);
        if (memcmp(mnt, targetroot_mnt, len) == 0) {
                if (mnt[len] == 0)
                        return "/";
                if (mnt[len] == '/')
                        return mnt + len;
        }
        return mnt;
        #undef SB
}

/* Ask for a partition offset, check bounds and do the needed roundups */
daddr_t
getpartoff(struct disk_partitions *parts, daddr_t defpartstart)
{
        char defstart[24], isize[24], maxpart, minspace, maxspace,
            *prompt, *label_msg, valid_parts[4], valid_spaces[4],
            space_prompt[1024], *head, *hint_part, *hint_space, *tail;
        size_t num_freespace, spaces, ndx;
        struct disk_part_free_space *freespace;
        daddr_t i, localsizemult, ptn_alignment, min, max;
        part_id partn;
        struct disk_part_info info;
        const char *errmsg = NULL;

        min = parts->disk_start;
        max = min + parts->disk_size;

        /* upper bound on the number of free spaces, plus some slope */
        num_freespace = parts->num_part * 2 + 5;
        freespace = calloc(num_freespace, sizeof(*freespace));
        if (freespace == NULL)
                return -1;

        ptn_alignment = parts->pscheme->get_part_alignment(parts);
        spaces = parts->pscheme->get_free_spaces(parts, freespace,
            num_freespace, max(sizemult, ptn_alignment), ptn_alignment, -1,
            defpartstart);

        maxpart = 'a' + parts->num_part -1;
        if (parts->num_part > 1) {
                snprintf(valid_parts, sizeof valid_parts, "a-%c", maxpart);
        } else if (parts->num_part == 1) {
                snprintf(valid_parts, sizeof valid_parts, "  %c", maxpart);
        } else {
                strcpy(valid_parts, "---");
        }
        if (spaces > 1) {
                minspace = maxpart + 1;
                maxspace = minspace + spaces -1;
                snprintf(valid_spaces, sizeof valid_spaces, "%c-%c", minspace,
                    maxspace);
        } else if (spaces == 1) {
                maxspace = minspace = maxpart + 1;
                snprintf(valid_spaces, sizeof valid_spaces, "  %c", minspace);
        } else {
                minspace = 0;
                maxspace = 0;
                strcpy(valid_spaces, "---");
        }

        /* Add description of start/size to user prompt */
        const char *mstr = msg_string(MSG_free_space_line);
        space_prompt[0] = 0;
        for (ndx = 0; ndx < spaces; ndx++) {
                char str_start[40], str_end[40], str_size[40], str_tag[4];

                sprintf(str_tag, "%c: ", minspace+(int)ndx);
                sprintf(str_start, "%" PRIu64, freespace[ndx].start / sizemult);
                sprintf(str_end, "%" PRIu64,
                    (freespace[ndx].start + freespace[ndx].size) / sizemult);
                sprintf(str_size, "%" PRIu64, freespace[ndx].size / sizemult);
                const char *args[4] = { str_start, str_end, str_size,
                    multname };
                char *line = str_arg_subst(mstr, 4, args);
                strlcat(space_prompt, str_tag, sizeof(space_prompt));
                size_t len = strlcat(space_prompt, line, sizeof(space_prompt));
                free (line);
                if (len >= sizeof space_prompt)
                        break;
        }

        const char *args[] = { valid_parts, valid_spaces, multname };
        hint_part = NULL;
        hint_space = NULL;
        head = str_arg_subst(msg_string(MSG_label_offset_head),
            __arraycount(args), args);
        if (parts->num_part)
                hint_part = str_arg_subst(msg_string(
                    MSG_label_offset_part_hint), __arraycount(args), args);
        if (spaces)
                hint_space = str_arg_subst(msg_string(
                    MSG_label_offset_space_hint), __arraycount(args), args);
        tail = str_arg_subst(msg_string(MSG_label_offset_tail),
            __arraycount(args), args);

        if (hint_part && hint_space)
                asprintf(&label_msg, "%s\n%s\n%s\n\n%s\n%s",
                    head, hint_part, hint_space, space_prompt, tail);
        else if (hint_part)
                asprintf(&label_msg, "%s\n%s\n\n%s",
                    head, hint_part, tail);
        else if (hint_space)
                asprintf(&label_msg, "%s\n%s\n\n%s\n%s",
                    head, hint_space, space_prompt, tail);
        else
                asprintf(&label_msg, "%s\n\n%s",
                    head, tail);
        free(head); free(hint_part); free(hint_space); free(tail);

        localsizemult = sizemult;
        errmsg = NULL;
        for (;;) {
                snprintf(defstart, sizeof defstart, "%" PRIu64,
                    defpartstart/sizemult);
                if (errmsg != NULL && errmsg[0] != 0)
                        asprintf(&prompt, "%s\n\n%s", errmsg, label_msg);
                else
                        prompt = label_msg;
                msg_prompt_win(prompt, -1, 13, 70, -1,
                    (defpartstart > 0) ? defstart : NULL, isize, sizeof isize);
                if (label_msg != prompt)
                        free(prompt);
                if (strcmp(defstart, isize) == 0) {
                        /* Don't do rounding if default accepted */
                        i = defpartstart;
                        break;
                }
                if (isize[1] == '\0' && isize[0] >= 'a' &&
                    isize[0] <= maxpart) {
                        partn = isize[0] - 'a';
                        if (parts->pscheme->get_part_info(parts, partn,
                            &info)) {
                                i = info.start + info.size;
                                localsizemult = 1;
                        } else {
                                errmsg = msg_string(MSG_invalid_sector_number);
                                continue;
                        }
                } else if (isize[1] == '\0' && isize[0] >= minspace &&
                    isize[0] <= maxspace) {
                        ndx = isize[0] - minspace;
                        i = freespace[ndx].start;
                        localsizemult = 1;
                } else if (atoi(isize) == -1) {
                        i = min;
                        localsizemult = 1;
                } else {
                        i = parse_disk_pos(isize, &localsizemult,
                            parts->bytes_per_sector,
                            parts->pscheme->get_cylinder_size(parts), NULL);
                        if (i < 0) {
                                errmsg = msg_string(MSG_invalid_sector_number);
                                continue;
                        }
                }
                /* round to cylinder size if localsizemult != 1 */
                int cylsize = parts->pscheme->get_cylinder_size(parts);
                i = NUMSEC(i, localsizemult, cylsize);
                /* Adjust to start of slice if needed */
                if ((i < min && (min - i) < localsizemult) ||
                    (i > min && (i - min) < localsizemult)) {
                        i = min;
                }
                if (max == 0 || i <= max)
                        break;
                errmsg = msg_string(MSG_startoutsidedisk);
        }
        free(label_msg);
        free(freespace);

        return i;
}


/* Ask for a partition size, check bounds and do the needed roundups */
daddr_t
getpartsize(struct disk_partitions *parts, daddr_t orig_start,
    daddr_t partstart, daddr_t dflt)
{
        char dsize[24], isize[24], max_size[24], maxpartc, valid_parts[4],
            *label_msg, *prompt, *head, *hint, *tail;
        const char *errmsg = NULL;
        daddr_t i, partend, diskend, localsizemult, max, max_r, dflt_r;
        struct disk_part_info info;
        part_id partn;

        diskend = parts->disk_start + parts->disk_size;
        max = parts->pscheme->max_free_space_at(parts, orig_start);
        max += orig_start - partstart;
        if (sizemult == 1)
                max--;  /* with hugher scale proper rounding later will be ok */

        /* We need to keep both the unrounded and rounded (_r) max and dflt */
        dflt_r = (partstart + dflt) / sizemult - partstart / sizemult;
        if (max == dflt)
                max_r = dflt_r;
        else
                max_r = max / sizemult;
        /* the partition may have been moved and now not fit any longer */
        if (dflt > max)
                dflt = max;
        if (dflt_r > max_r)
                dflt_r = max_r;

        snprintf(max_size, sizeof max_size, "%" PRIu64, max_r);

        maxpartc = 'a' + parts->num_part -1;
        if (parts->num_part > 1) {
                snprintf(valid_parts, sizeof valid_parts, "a-%c", maxpartc);
        } else if (parts->num_part == 1) {
                snprintf(valid_parts, sizeof valid_parts, "  %c", maxpartc);
        } else {
                strcpy(valid_parts, "---");
        }

        const char *args[] = { valid_parts, max_size, multname };
        hint = NULL;
        head = str_arg_subst(msg_string(MSG_label_size_head),
            __arraycount(args), args);
        if (parts->num_part)
                hint  = str_arg_subst(msg_string(MSG_label_size_part_hint),
                    __arraycount(args), args);
        tail = str_arg_subst(msg_string(MSG_label_size_tail),
            __arraycount(args), args);

        if (hint != NULL)
                asprintf(&label_msg, "%s\n%s\n\n%s", head, hint, tail);
        else
                asprintf(&label_msg, "%s\n\n%s", head, tail);
        free(head); free(hint); free(tail);

        localsizemult = sizemult;
        i = -1;
        for (;;) {
                snprintf(dsize, sizeof dsize, "%" PRIu64, dflt_r);

                if (errmsg != NULL && errmsg[0] != 0)
                        asprintf(&prompt, "%s\n\n%s", errmsg, label_msg);
                else
                        prompt = label_msg;
                msg_prompt_win(prompt, -1, 12, 70, -1,
                    (dflt != 0) ? dsize : 0, isize, sizeof isize);
                if (prompt != label_msg)
                        free(prompt);

                if (strcmp(isize, dsize) == 0) {
                        free(label_msg);
                        return dflt;
                }
                if (parts->num_part && isize[1] == '\0' && isize[0] >= 'a' &&
                    isize[0] <= maxpartc) {
                        partn = isize[0] - 'a';
                        if (parts->pscheme->get_part_info(parts, partn,
                            &info)) {
                                i = info.start - partstart -1;
                                localsizemult = 1;
                                max_r = max;
                        }
                } else if (atoi(isize) == -1) {
                        i = max;
                        localsizemult = 1;
                        max_r = max;
                } else {
                        i = parse_disk_pos(isize, &localsizemult,
                            parts->bytes_per_sector,
                            parts->pscheme->get_cylinder_size(parts), NULL);
                        if (localsizemult != sizemult)
                                max_r = max;
                }
                if (i < 0) {
                        errmsg = msg_string(MSG_Invalid_numeric);
                        continue;
                } else if (i > max_r) {
                        errmsg = msg_string(MSG_Too_large);
                        continue;
                }
                /*
                 * partend is aligned to a cylinder if localsizemult
                 * is not 1 sector
                 */
                int cylsize = parts->pscheme->get_cylinder_size(parts);
                partend = NUMSEC((partstart + i*localsizemult) / localsizemult,
                    localsizemult, cylsize);
                /* Align to end-of-disk or end-of-slice if close enough */
                if (partend > (diskend - sizemult)
                    && partend < (diskend + sizemult))
                        partend = diskend;
                if (partend > (partstart + max - sizemult)
                    && partend < (partstart + max + sizemult))
                        partend = partstart + max;
                /* sanity checks */
                if (partend > diskend) {
                        partend = diskend;
                        errmsg = msg_string(MSG_endoutsidedisk);
                        continue;
                }
                free(label_msg);
                if (partend < partstart)
                        return 0;
                return (partend - partstart);
        }
        /* NOTREACHED */
}

/*
 * convert a string to a number of sectors, with a possible unit
 * 150M = 150 Megabytes
 * 2000c = 2000 cylinders
 * 150256s = 150256 sectors
 * Without units, use the default (sizemult).
 * returns the raw input value, and the unit used. Caller needs to multiply!
 * On invalid inputs, returns -1.
 */
daddr_t
parse_disk_pos(
        const char *str,
        daddr_t *localsizemult,
        daddr_t bps,
        daddr_t cyl_size,
        bool *extend_this)
{
        daddr_t val;
        char *cp;
        bool mult_found;

        if (str[0] == '\0') {
                return -1;
        }
        val = strtoull(str, &cp, 10);
        mult_found = false;
        if (extend_this)
                *extend_this = false;
        while (*cp != 0) {
                if (*cp == 'G' || *cp == 'g') {
                        if (mult_found)
                                return -1;
                        *localsizemult = GIG / bps;
                        goto next;
                }
                if (*cp == 'M' || *cp == 'm') {
                        if (mult_found)
                                return -1;
                        *localsizemult = MEG / bps;
                        goto next;
                }
                if (*cp == 'c' || *cp == 'C') {
                        if (mult_found)
                                return -1;
                        *localsizemult = cyl_size;
                        goto next;
                }
                if (*cp == 's' || *cp == 'S') {
                        if (mult_found)
                                return -1;
                        *localsizemult = 1;
                        goto next;
                }
                if (*cp == '+' && extend_this) {
                        *extend_this = true;
                        cp++;
                        break;
                }

                /* not a known unit */
                return -1;

next:
                mult_found = true;
                cp++;
                continue;
        }
        if (*cp != 0)
                return -1;

        return val;
}