/*      $OpenBSD: pdisk.c,v 1.87 2016/05/28 22:26:13 tb Exp $   */

/*
 * pdisk - an editor for Apple format partition tables
 *
 * Written by Eryk Vershen
 *
 * Still under development (as of 15 January 1998)
 */

/*
 * Copyright 1996,1997,1998 by Apple Computer, Inc.
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>          /* DEV_BSIZE */
#include <sys/dkio.h>
#include <sys/disklabel.h>
#include <sys/ioctl.h>
#include <sys/queue.h>
#include <sys/stat.h>

#include <err.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>

#include "partition_map.h"
#include "io.h"
#include "dump.h"

int     lflag;  /* list the device */
int     rflag;  /* open device read Only */

static int      first_get = 1;

void    do_dump_map(struct partition_map *, int);
void    do_change_map_size(struct partition_map *);
void    do_create_partition(struct partition_map *, int);
void    do_delete_partition(struct partition_map *);
void    do_display_entry(struct partition_map *);
void    do_rename_partition(struct partition_map *);
void    do_change_type(struct partition_map *);
void    do_reorder(struct partition_map *);
void    do_write_partition_map(struct partition_map *);
void    edit(struct partition_map **);
int     get_base_argument(long *, struct partition_map *);
int     get_size_argument(long *, struct partition_map *);

__dead static void usage(void);

int
main(int argc, char **argv)
{
        struct disklabel dl;
        struct stat st;
        struct partition_map *map;
        int c, fd, oflags;

        oflags = O_RDWR;
        while ((c = getopt(argc, argv, "lr")) != -1) {
                switch (c) {
                case 'l':
                        lflag = 1;
                        oflags = O_RDONLY;
                        break;
                case 'r':
                        rflag = 1;
                        oflags = O_RDONLY;
                        break;
                default:
                        usage();
                        break;
                }
        }

        argc -= optind;
        argv += optind;

        if (argc != 1)
                usage();

        fd = opendev(*argv, oflags, OPENDEV_PART, NULL);
        if (fd == -1)
                err(1, "can't open file '%s'", *argv);

        if (fstat(fd, &st) == -1)
                err(1, "can't fstat %s", *argv);
        if (!S_ISCHR(st.st_mode))
                errx(1, "%s is not a character device", *argv);

        if (ioctl(fd, DIOCGPDINFO, &dl) == -1)
                err(1, "can't get disklabel for %s", *argv);
        if (dl.d_secsize != DEV_BSIZE)
                errx(1, "disk sector size (%d) != 512\n", dl.d_secsize);

        if (pledge("stdio", NULL) == -1)
                err(1, "pledge");

        map = open_partition_map(fd, *argv, DL_GETDSIZE(&dl), dl.d_secsize);
        if (map != NULL) {
                if (lflag)
                        dump_partition_map(map);
                else
                        edit(&map);
        }

        free_partition_map(map);
        close(fd);

        return 0;
}

/*
 * Edit the file
 */
void
edit(struct partition_map **mapp)
{
        struct partition_map *map = *mapp;
        struct partition_map *oldmap;
        int command;

        printf("Edit %s -\n", map->name);

        while (get_command("Command (? for help): ", first_get, &command)) {
                first_get = 0;

                switch (command) {
                case '?':
                        printf("Notes:\n"
                            "  Base and length fields are blocks, which "
                            "vary in size between media.\n"
                            "  The base field can be <nth>p; i.e. the "
                            "base of the nth partition.\n"
                            "  The length field can be a length followed "
                            "by k, m, g or t to indicate\n"
                            "    kilo, mega, giga, or tera bytes.\n"
                            "  The length field can also be <nth>p; i.e. "
                            "the length of the nth partition.\n"
                            "  The name of a partition is descriptive "
                            "text.\n\n");

                        /* fall through */
                case 'h':
                        printf("Commands are:\n"
                            "  ?    verbose command help\n"
                            "  C    create a partition of a specified type\n"
                            "  c    create an OpenBSD partition\n"
                            "  d    delete a partition\n"
                            "  f    full display of a partition\n"
                            "  h    command help\n"
                            "  i    (re)initialize the partition map\n"
                            "  n    (re)name a partition\n"
                            "  P    show the partition map's data structures\n"
                            "  p    print the partition map\n"
                            "  q    quit editing\n"
                            "  r    reorder (swap) disk positions of two "
                                "entries in the partition map\n"
                            "  s    change the size of the partition map\n"
                            "  t    change the type of a partition\n"
                            "  w    write the partition map to disk\n");
                        break;
                case 'P':
                        do_dump_map(map, 1);
                        break;
                case 'p':
                        do_dump_map(map, 0);
                        break;
                case 'q':
                        if (map->changed) {
                                if (get_okay("Discard changes? [n/y]: ", 0) !=
                                    1) {
                                        break;
                                }
                        }
                        flush_to_newline(1);
                        return;
                case 'i':
                        if (get_okay("Discard current map? [n/y]: ", 0) == 1) {
                                oldmap = map;
                                map = create_partition_map(oldmap->fd,
                                    oldmap->name, oldmap->media_size,
                                    oldmap->sbBlkSize);
                                if (map == NULL)
                                        break;
                                *mapp = map;
                                free_partition_map(oldmap);
                        }
                        break;
                case 'C':
                        do_create_partition(map, 1);
                        break;
                case 'c':
                        do_create_partition(map, 0);
                        break;
                case 'n':
                        do_rename_partition(map);
                        break;
                case 'd':
                        do_delete_partition(map);
                        break;
                case 'r':
                        do_reorder(map);
                        break;
                case 's':
                        do_change_map_size(map);
                        break;
                case 't':
                        do_change_type(map);
                        break;
                case 'w':
                        do_write_partition_map(map);
                        break;
                case 'f':
                        do_display_entry(map);
                        break;
                default:
                        bad_input("No such command (%c)", command);
                        break;
                }
        }
}

void
do_create_partition(struct partition_map *map, int get_type)
{
        long base, length;
        char *name = NULL;
        char *type = NULL;

        if (get_base_argument(&base, map) == 0)
                return;
        if (get_size_argument(&length, map) == 0)
                return;

        name = get_dpistr_argument("Name of partition: ");
        if (name == NULL) {
                bad_input("Bad name");
                goto out;
        }

        if (get_type == 0)
                type = strdup(kUnixType);
        else
                type = get_dpistr_argument("Type of partition: ");
        if (type == NULL) {
                bad_input("Bad type");
                goto out;
        }

        if (strncasecmp(type, kFreeType, DPISTRLEN) == 0) {
                bad_input("Can't create a partition with the Free type");
                goto out;
        }
        if (strncasecmp(type, kMapType, DPISTRLEN) == 0) {
                bad_input("Can't create a partition with the Map type");
                goto out;
        }

        add_partition_to_map(name, type, base, length, map);

out:
        free(type);
        free(name);

        return;
}

int
get_base_argument(long *number, struct partition_map *map)
{
        struct entry *entry;
        int result = 0;

        if (get_number_argument("First block: ", number) == 0) {
                bad_input("Bad block number");
        } else {
                result = 1;
                if (get_partition_modifier()) {
                        entry = find_entry_by_disk_address(*number, map);
                        if (entry == NULL) {
                                bad_input("Bad partition number");
                                result = 0;
                        } else {
                                *number = entry->dpme_pblock_start;
                        }
                }
        }
        return result;
}


int
get_size_argument(long *number, struct partition_map *map)
{
        struct entry *entry;
        unsigned long multiple;
        int result = 0;

        if (get_number_argument("Length in blocks: ", number) == 0) {
                bad_input("Bad length");
        } else {
                multiple = get_multiplier(map->sbBlkSize);
                if (multiple == 0) {
                        bad_input("Bad multiplier");
                } else if (multiple != 1) {
                        *number *= multiple;
                        result = 1;
                } else if (get_partition_modifier()) {
                        entry = find_entry_by_disk_address(*number, map);
                        if (entry == NULL) {
                                bad_input("Bad partition number");
                        } else {
                                *number = entry->dpme_pblocks;
                                result = 1;
                        }
                } else {
                        result = 1;
                }
        }
        return result;
}


void
do_rename_partition(struct partition_map *map)
{
        struct entry *entry;
        char *name;
        long ix;

        if (get_number_argument("Partition number: ", &ix) == 0) {
                bad_input("Bad partition number");
                return;
        }
        entry = find_entry_by_disk_address(ix, map);
        if (entry == NULL) {
                printf("No such partition\n");
                return;
        }

        printf("Existing partition name ``%s''.\n", entry->dpme_name);
        name = get_dpistr_argument("New name of partition: ");
        if (name == NULL) {
                bad_input("Bad name");
                return;
        }

        /*
         * Since dpme_name is supposed to be NUL-filled, make sure
         * current contents are zapped before copying in new name!
         */
        memset(entry->dpme_name, 0, sizeof(entry->dpme_name));
        strlcpy(entry->dpme_name, name, sizeof(entry->dpme_name));
        map->changed = 1;

        free(name);
        return;
}

void
do_change_type(struct partition_map *map)
{
        struct entry *entry;
        char *type;
        long ix;

        if (get_number_argument("Partition number: ", &ix) == 0) {
                bad_input("Bad partition number");
                return;
        }
        entry = find_entry_by_disk_address(ix, map);
        if (entry == NULL) {
                printf("No such partition\n");
                return;
        }

        printf("Existing partition type ``%s''.\n", entry->dpme_type);
        type = get_dpistr_argument("New type of partition: ");
        if (type == NULL) {
                bad_input("Bad type");
                return;
        }

        /*
         * Since dpme_type is supposed to be NUL-filled, make sure
         * current contents are zapped before copying in new type!
         */
        memset(entry->dpme_type, 0, sizeof(entry->dpme_type));
        strncpy(entry->dpme_type, type, sizeof(entry->dpme_type));
        map->changed = 1;

        free(type);
        return;
}


void
do_delete_partition(struct partition_map *map)
{
        struct entry *cur;
        long ix;

        if (get_number_argument("Partition number: ", &ix) == 0) {
                bad_input("Bad partition number");
                return;
        }

        cur = find_entry_by_disk_address(ix, map);
        if (cur == NULL)
                printf("No such partition\n");
        else
                delete_partition_from_map(cur);
}


void
do_reorder(struct partition_map *map)
{
        long ix, old_index;

        if (get_number_argument("Partition number: ", &old_index) == 0) {
                bad_input("Bad partition number");
                return;
        }
        if (get_number_argument("New number: ", &ix) == 0) {
                bad_input("Bad partition number");
                return;
        }
        move_entry_in_map(old_index, ix, map);
}


void
do_write_partition_map(struct partition_map *map)
{
        if (map->changed == 0) {
                bad_input("The map has not been changed.");
                return;
        }
        if (rflag) {
                bad_input("The map is not writable.");
                return;
        }
        printf("Writing the map destroys what was there before. ");
        if (get_okay("Is that okay? [n/y]: ", 0) != 1) {
                return;
        }
        write_partition_map(map);

        map->changed = 0;
}


void
do_change_map_size(struct partition_map *map)
{
        long size;

        if (get_number_argument("New size: ", &size) == 0) {
                bad_input("Bad size");
                return;
        }
        resize_map(size, map);
}


void
do_display_entry(struct partition_map *map)
{
        long number;

        if (get_number_argument("Partition number: ", &number) == 0) {
                bad_input("Bad partition number");
                return;
        }
        if (number == 0)
                full_dump_block_zero(map);
        else
                full_dump_partition_entry(map, number);
}

void
do_dump_map(struct partition_map *map, int verbose)
{
        if (verbose)
                show_data_structures(map);
        else
                dump_partition_map(map);
}

__dead static void
usage(void)
{
        extern char *__progname;

        fprintf(stderr, "usage: %s [-lr] disk\n", __progname);

        exit(1);
}