#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>

#include "libfdisk.h"

#include "fstab.h"
#include "fsedit.h"
#include "newtfsedit.h"

#include "isys.h"

#define _(a) a

/* this isn't const, as we have a loop which does i18n conversion on these */
struct parttypes allparttypes[] = {
    {0, "Empty"},
    {SUNPARTTYPE|1, "Boot"},
    {SUNPARTTYPE|2, "SunOS root"},
    {SUNPARTTYPE|3, "SunOS swap"},
    {SUNPARTTYPE|4, "SunOS usr"},
    {SUNPARTTYPE|5, "Whole disk"},
    {SUNPARTTYPE|6, "SunOS stand"},
    {SUNPARTTYPE|7, "SunOS var"},
    {SUNPARTTYPE|8, "SunOS home"},
    {NONSUNPARTTYPE|1, "DOS 12-bit FAT"},
    {NONSUNPARTTYPE|2, "XENIX root"},
    {NONSUNPARTTYPE|3, "XENIX usr"},
    {NONSUNPARTTYPE|4, "DOS 16-bit <32M"},
    {NONSUNPARTTYPE|5, "Extended"},
    {NONSUNPARTTYPE|6, "DOS 16-bit >=32M"},
    {NONSUNPARTTYPE|7, "OS/2 HPFS"},               /* or QNX? */
    {NONSUNPARTTYPE|8, "AIX"},
    {9, "AIX bootable"},
    {10, "OS/2 Boot Manager"},
    {0xb, "Win95 FAT32"},
    {0xc, "Win95 FAT32"},
    {0xe, "Win95 FAT32"},
    {0x40, "Venix 80286"},
    {0x51, "Novell?"},
    {0x52, "Microport"},            /* or CPM? */
    {0x63, "GNU HURD"},             /* or System V/386? */
    {0x64, "Novell Netware 286"},
    {0x65, "Novell Netware 386"},
    {0x75, "PC/IX"},
    {0x80, "Old MINIX"},            /* Minix 1.4a and earlier */

    {0x81, "Linux/MINIX"}, /* Minix 1.4b and later */
    {0x82, "Linux swap"},
    {0x83, "Linux native"},
    {0xfd, "Linux RAID"},

    {0x93, "Amoeba"},
    {0x94, "Amoeba BBT"},           /* (bad block table) */
    {0xa5, "BSD/386"},
    {0xb7, "BSDI fs"},
    {0xb8, "BSDI swap"},
    {0xc7, "Syrinx"},
    {0xdb, "CP/M"},                 /* or Concurrent DOS? */
    {0xe1, "DOS access"},
    {0xe3, "DOS R/O"},
    {0xf2, "DOS secondary"},
    {0xff, "BBT"}                   /* (bad track table) */
};

struct repartitionInfo {
    HardDrive ** hdarr;
    int numDrives;
};

int nparttypes = sizeof (allparttypes) / sizeof (struct parttypes);

static int HandleFdiskError( int status, char *errbody, char *y, char *n );
static int ErrorDialog(char *title, char *errbody, char *errmsg,
		       char *yesmsg, char *nomsg);
int ReadDrives( char **drives, int numdrives,
		HardDrive **hdarr, unsigned int *numhd,
		int forcezero, int readOnly, int testing, int autoClearMbr);
void setupGlobalContextEvenThoughYouShouldNeverUseGlobalVariables(
		FseditContext * context);

char * nstrdup(const char * foo) {
    return foo ? strdup(foo) : NULL;
}

struct attemptedPartition normalPartitioning[] = {
#if defined(__i386__)
	{ "/boot",	16,	LINUX_NATIVE_PARTITION,	0, -1 },
#elif defined(__alpha__)
	{ "/dos",	2,	DOS_PRIMARY_lt32MEG_PARTITION,	0, 1 },
#endif
	{ "/",		400,	LINUX_NATIVE_PARTITION,	1, -1 },
	{ "Swap-auto",	64,	LINUX_SWAP_PARTITION,	0, -1 },
	{ NULL, 0, 0, 0 }
};

struct attemptedPartition serverPartitioning[] = {
#if defined(__i386__)
        { "/boot",      16,     LINUX_NATIVE_PARTITION, 0, -1 },
#elif defined(__alpha__)
        { "/dos",       2,      DOS_PRIMARY_lt32MEG_PARTITION,  0, 1 },
#endif
        { "/",          256,    LINUX_NATIVE_PARTITION, 0, -1 },
        { "/usr",       512,    LINUX_NATIVE_PARTITION, 1, -1 },
        { "/var",       256,    LINUX_NATIVE_PARTITION, 0, -1 },
        { "/home",      512,    LINUX_NATIVE_PARTITION, 1, -1 },
        { "Swap-auto",  64,     LINUX_SWAP_PARTITION,   0, -1 },
        { NULL, 0, 0, 0 } 
};



/* XXXX - temporary debugging function */

void print_user_partition_table(HardDrive *hd) {
    int i;
    Partition *up;
    unsigned int first, last, end;
    unsigned int s_cyl, s_hd, s_sec, e_cyl, e_hd, e_sec;

    
    printf("Nr AF     Start C/H/S     End C/H/S      Start      Size    ID\n");

    /* print primary partitions first */
    fdiskFirstPartition( hd, &first );
    fdiskLastPartition( hd, &last );
    for (i=first; i<=last; i++) {
        up = &hd->table[i];
        if (!(up->size.current) || !(up->type.current))
            continue;

        fdiskSectorToCHS( hd, up->start.current, &s_cyl, &s_hd, &s_sec );
        end = up->start.current + up->size.current - 1;
        fdiskSectorToCHS( hd, end, &e_cyl, &e_hd, &e_sec );
        printf("%2d %2x   [%4d/%3d/%3d]  [%4d/%3d/%3d] %7d   %7d    %2x\n",
               up->num.current,
               up->active.current,
               s_cyl, s_hd, s_sec,
               e_cyl, e_hd, e_sec,
               up->start.current,
               up->size.current,
               up->type.current);
    }

}

int guessAtPartitioning(FseditContext *context, int flags, char *name,
			struct attemptedPartition * goals,
			int interactive) {
    int i, rc;
    int numhd;
    HardDrive *tmphdarr[MAX_HARDDRIVES];
    HardDrive *hdarr[MAX_HARDDRIVES];
    PartitionSpec *spec;

    /*struct newtColors colors = newtDefaultColorPalette;*/

    /* make local copies because we're going to do massive modification */
    numhd = context->numhd;
    for (i=0; i<numhd; i++) {
	hdarr[i] = (HardDrive *) alloca(sizeof(HardDrive));
	memcpy(hdarr[i], context->hdarr[i], sizeof(HardDrive));

	tmphdarr[i] = (HardDrive *) alloca(sizeof(HardDrive));
	memcpy(tmphdarr[i], context->hdarr[i], sizeof(HardDrive));
    }
    
    MergeFstabEntries( context->hdarr, context->numhd,
		       &context->spec, &context->fstab );

    spec = (PartitionSpec *) alloca(sizeof(PartitionSpec));
    memset(spec, 0, sizeof(PartitionSpec));
    spec->num = context->spec.num;
    for (i=0; i<spec->num; i++) {
	spec->entry[i].name = strdup(context->spec.entry[i].name);
	memcpy(&spec->entry[i].partition, 
	       &context->spec.entry[i].partition, 
	       sizeof(Partition));
	spec->entry[i].status = context->spec.entry[i].status;
    }

    /* check flags are remove requested partition classes from */
    /* existing partition spec and original partitions         */
    /* (original partitions are those which were on the drive  */
    /* before we started editting the partition tables)        */
    if (flags & (FSEDIT_CLEARLINUX | FSEDIT_CLEARALL)) {
	rc = -1;
	
	if (flags & FSEDIT_CLEARLINUX) {
	    deletePartitionClass(hdarr, numhd, spec, FSEDIT_CLEARLINUX);
	} else {
	    deletePartitionClass(hdarr, numhd, spec, 0);
	}
    }

    rc = tryGoal(hdarr, tmphdarr, numhd, spec, goals);
    if (rc) {
	/* release memory */ 
	fdiskWipePartitionSpec(spec);
	return INST_CANCEL;
    }

    for (i=0; i<numhd; i++) {
	*context->hdarr[i] = *tmphdarr[i];
	*context->newhdarr[i] = *tmphdarr[i];
    }
    
    /* erase old partition spec and replace with new */
    fdiskWipePartitionSpec (&context->spec);
    
    context->spec.num = spec->num;
    memcpy(context->spec.entry, spec->entry, 
	   MAX_PARTITION_SPEC*sizeof(PartitionSpecEntry));

    exitFsedit (context, NULL);

    return 0;
}

/* clean up that string */
void TrimWhitespace( char *s ) {
    char *f, *l, *p, *q;

    if (!(*s))
        return;
    
    for (f=s; *f && isspace(*f); f++) ;

    if (!*f) {
        *s = '\0';
        return;
    }
    
    for (l=f+strlen(f)-1; isspace(*l) ; l--)
    *l = '\0';
        
    q = s, p = f;
    while (*p)
        *q++ = *p++;
    
    *q = '\0';
}

/* see if anything really changed */
int DisksChanged( HardDrive **oldhd, HardDrive **newhd, unsigned int numhd ) {
    int i, j;
    
    /* see if partition tables are identical */
    for (i=0; i<numhd; i++)
	for (j=0; j<MAX_PARTITIONS; j++) {
	    if (memcmp(&oldhd[i]->table[j],&newhd[i]->table[j],
		       sizeof(Partition)))
		return 1;
	    if (memcmp(&oldhd[i]->eptable[j],&newhd[i]->eptable[j],
		       sizeof(Partition)))
		return 1;
	}

    return 0;
}
		
/* delete a partition spec */
int doDeletePartitionSpec( HardDrive **hdarr, unsigned int numhd,
			 PartitionSpec *spec, PartitionSpecEntry *entry){
    Partition *p;
    int      status;
    unsigned int c, l, m, n, t;
    char     *tmpstr;

    p = &entry->partition;

    tmpstr=strdup(entry->name);
    
    if (p->immutable) {
	fdiskGetCurrentConstraint(&p->num, &c);
	fdiskGetCurrentConstraint(&p->type, &t);
	fdiskGetCurrentDriveSet(&p->drive, &l);
	for (m=0; m<numhd; m++)
	    if (hdarr[m]->num == l)
		break;
	
	fdiskRemovePartition(hdarr[m], c);

	/* make it so we can delete this partition now */
	p->immutable = 0;
	fdiskModifyPartitionSpec( spec, tmpstr, p, REQUEST_PENDING );

	/* ok, see if this was the last immutable logical partition */
	/* in an immutable primary extended partition               */
	/* we pray that fdiskCleanOriginal... will get rid of the   */
	/* spec entry for the pep                                   */
	if (c > 4) {
	    if (fdiskLastLogical( hdarr[m], &n ) != FDISK_SUCCESS) {
		/* all logicals are gone, blow away pep */
		if (hdarr[m]->pep && hdarr[m]->table[hdarr[m]->pep].immutable){
		    fdiskRemovePartition(hdarr[m], hdarr[m]->pep);
		}
	    }
	}
    }
    
    status = fdiskDeletePartitionSpec( spec, tmpstr );
    fdiskHandleSpecialPartitions( spec );
    free(tmpstr);

    return FDISK_SUCCESS;
}

/* converts a PartionSpec to an equivalent struct fstab */
/* Creates fstab from scratch                           */
int PartitionSpecToFstab( HardDrive **hdarr, int numhd,
			  PartitionSpec *spec, struct fstab *fstab ) {

    int i, j;
    struct fstabEntry entry;
    
    fstab->entries = malloc(sizeof(*fstab->entries) * spec->num);
    fstab->numEntries = 0;
    for (i = 0; i < spec->num; i++) {
	if (!spec->entry[i].name) continue;
	
	if (spec->entry[i].status != REQUEST_ORIGINAL &&
	    spec->entry[i].status != REQUEST_GRANTED)
	    continue;
	
	/* FIXME: hack, hack, hack */
	if (*spec->entry[i].name != '/' &&
	    *spec->entry[i].name != 'S') continue;
	
	for (j=0; j<numhd; j++)
	    if (hdarr[j]->num == spec->entry[i].partition.drive.current)
		break;
	
	if (j == numhd)
	    continue;

	initFstabEntry(&entry);
	entry.mntpoint = strdup(spec->entry[i].name);
	entry.size = spec->entry[i].partition.size.current / 2;

	entry.device = malloc(6);
	sprintf(entry.device, "%s%d",
		hdarr[j]->prefix, spec->entry[i].partition.num.current);
	
	switch (spec->entry[i].partition.type.current) {
	  case LINUX_NATIVE_PARTITION:
	    entry.type = PART_EXT2;
	    entry.tagName = "Linux native";
	    break;
	    
	  case LINUX_SWAP_PARTITION:
	    entry.type = PART_SWAP;
	    entry.tagName = "Linux swap";
	    break;
	    
	  case DOS_PRIMARY_lt32MEG_PARTITION:
	  case DOS_PRIMARY_gt32MEG_PARTITION:
	    entry.type = PART_DOS;
	    entry.tagName = "DOS 16-bit >=32";
	    break;
	    
	  default:
	    entry.type = PART_OTHER;
	    entry.tagName = "Other";
	    break;
	}

	addFstabEntry(fstab, entry);
    }
    
    fstabSort(fstab);
    return 0;
}


/* merges mount point info from existing struct fstab into a PartionSpec     */
/* PartitionSpec should already exist and be primed with existing partitions */
/* Note - remote fs ARE NOT stored in the PartitionSpec                      */
int MergeFstabEntries( HardDrive **hdarr, int numhd,
			      PartitionSpec *spec, struct fstab *fstab ) {

    int i, j, k;
    char device[15];
    
    for (j = 0; j < spec->num; j++) {
	for (k=0; k<numhd; k++)
	    if (hdarr[k]->num == spec->entry[j].partition.drive.current)
		break;
	
	if (k == numhd)
	    continue;

	sprintf(device, "%s%d",
		hdarr[k]->prefix, spec->entry[j].partition.num.current);
	
	for (i = 0; i < fstab->numEntries; i++)
	    if (!strcmp(fstab->entries[i].device, device))
		break;

	if ( i == fstab->numEntries )
	    continue;

	/* we found a matching entry in the PartitionSpec */
	/* see if the old fstab file had any info we need */
	/* to use (like mount point, etc)                 */
	if (spec->entry[j].name)
	    free(spec->entry[j].name);

	spec->entry[j].name = strdup(fstab->entries[i].mntpoint);
    }

    return 0;
}

/* suck out just the remote fs entries from an fstab */
/* pretty much CopyFstab, with filter on type        */
struct fstab copyRemoteFSFstab(struct fstab * fstab) {
    struct fstab newfstab;
    int i, j;

    if (!fstab->numEntries) {
        newfstab.numEntries = 0;
        newfstab.entries = malloc(1);
        return newfstab;
    }

    /* duplicate the current fstab */
    newfstab.numEntries = fstab->numEntries;
    newfstab.entries = malloc(fstab->numEntries * sizeof(struct fstabEntry));
    for (i = j = 0; i < newfstab.numEntries; i++) {
	if (fstab->entries[i].type != PART_NFS)
	    continue;
	
        if (fstab->entries[i].mntpoint) {
            newfstab.entries[j] = fstab->entries[i];
            newfstab.entries[j].mntpoint=nstrdup(fstab->entries[i].mntpoint);
            newfstab.entries[j].device = nstrdup(fstab->entries[i].device);
            newfstab.entries[j].netPath = nstrdup(fstab->entries[i].netPath);
            newfstab.entries[j].netHost = nstrdup(fstab->entries[i].netHost);
            j++;
        }
    }

    newfstab.numEntries = j;

    /* return the memory we don't actually need */
    newfstab.entries=realloc(newfstab.entries, j * sizeof(struct fstabEntry));

    return newfstab;
}


/* suck out just the remote fs entries from an fstab */
/* pretty much CopyFstab, with filter on type        */
void MergeRemoteFSFstab(struct fstab *oldfstab, struct fstab *newfstab) {
    int i, j;

    /* copy remote fs entries */
    for (i = 0; i < oldfstab->numEntries; i++) {
	if (oldfstab->entries[i].type != PART_NFS)
	    continue;
	
        if (oldfstab->entries[i].mntpoint) {
	    j = newfstab->numEntries;
	    newfstab->entries = realloc(newfstab->entries,
				     (j+1)*sizeof(struct fstabEntry));
	    newfstab->entries[j] = oldfstab->entries[i];
            newfstab->entries[j].mntpoint=nstrdup(oldfstab->entries[i].mntpoint);
            newfstab->entries[j].device=nstrdup(oldfstab->entries[i].device);
            newfstab->entries[j].netPath=nstrdup(oldfstab->entries[i].netPath);
            newfstab->entries[j].netHost=nstrdup(oldfstab->entries[i].netHost);
	    newfstab->numEntries = j+1;
        }
    }
}

int deletePartitionClass(HardDrive ** hd, int numhd, 
				PartitionSpec * spec, int justLinux) {
    int deleteit;
    int type;
    int i;

    i = 0;
    while (i < spec->num) {
	type = spec->entry[i].partition.type.current;

	deleteit = !justLinux;
	if (justLinux && (type == LINUX_SWAP_PARTITION || 
			  type == LINUX_NATIVE_PARTITION ||
			  type == LINUX_RAID_PARTITION))
	    deleteit = 1;

	if (deleteit) {
	    doDeletePartitionSpec(hd, numhd, spec, &spec->entry[i]);
	    fdiskCleanOriginalSpecs( hd, numhd, spec );
	    i=0; /* restart cause entries changed */
	    continue;
	} else {
	    i++;
	}
    }

    return 0;
}

int addNewPartition(PartitionSpec * spec, 
		           char * where, int megs, int grow, int bootable, 
		           unsigned char type, int startCyl) {
    Partition template;
    
    /* create a template partitionspec to send to editpartition */
    memset(&template, 0, sizeof(Partition));
    fdiskSetFixedConstraint(&template.type, type);

    if (bootable) {
	fdiskDeactivateAllDriveSet( &template.drive );
	fdiskActivateDriveSet(&template.drive, 1);
	fdiskActivateDriveSet(&template.drive, 2);
	fdiskSetConstraint(&template.endcyl, 0, 0, 1023, 1);
    } else {
	fdiskActivateAllDriveSet( &template.drive );
    }

/*  For now we'll make this alpha only code  */
#ifdef __alpha__

    if (startCyl != -1) {
	/* XXX HACK */
	/* Add a little buffer in case we need to skip a head */
	fdiskSetConstraint(&template.start, 0, startCyl, startCyl + 100, 1);
    }

#endif

    fdiskSetConstraint(&template.size, SECPERMEG * megs, SECPERMEG * megs,
			grow ? FDISK_SIZE_MAX : SECPERMEG * megs, 1);

    /* insert with a name we know to mean its a new partition */
    fdiskInsertPartitionSpec(spec, where, &template, 
				  REQUEST_PENDING);
    
    return 0;
}

int tryGoal(HardDrive ** hdarr, HardDrive ** tmphdarr, int numhd, 
		   PartitionSpec * spec, struct attemptedPartition * goals) {
    int i;

    for (i = 0; goals[i].mount; i++)
	addNewPartition(spec, goals[i].mount, goals[i].size, 
			goals[i].grow, !strcmp(goals[i].mount, "/boot"),
			goals[i].type, goals[i].start);

    /* insert the new partition spec */
    fdiskAutoInsertPartitions(hdarr, numhd, tmphdarr, spec );
    fdiskGrowPartitions(hdarr, numhd, tmphdarr, spec);

    for (i = 0; i < spec->num; i++)
	if (spec->entry[i].status == REQUEST_DENIED)
	    break;

    return (i < spec->num);
}

static char ** createDevices(char ** drives, int numDrives) {
    int i, rc;
    char ** deviceList;

    deviceList = malloc(numDrives * sizeof(char *));

    for (i = 0; i < numDrives; i++) {
	deviceList[i] = malloc(15);
	strcpy(deviceList[i], "/tmp/");
	strcat(deviceList[i], drives[i]);
#ifndef MSF_PARANOID
	if ((rc = devMakeInode(drives[i], deviceList[i]))) return NULL;
#endif
    }

    return deviceList;
}

#if 0 /* not used */
static void removeDevices(char ** deviceList, int numDrives) {
    int i;

    for (i = 0; i < numDrives; i++) {
	unlink(deviceList[i]);
    	free(deviceList[i]);
    }

    free(deviceList);
}
#endif

/* check a mount point to make sure its valid */
/* returns non-zero if bad mount point        */
int badMountPoint(unsigned int type, char * item) {
    char * chptr = item;

    if (!strcmp(item, "/dev") ||
        !strcmp(item, "/bin") ||
        !strcmp(item, "/sbin") ||
        !strcmp(item, "/etc") ||
#ifdef __sparc__
        !strcmp(item, "/boot") ||
#endif
        !strcmp(item, "/lib")) {
        ddruidShowMessage(_("Bad Mount Point"), _("Ok"),
                    _("The %s directory must be on the root filesystem."),
		    item);
	return 1;
    }

    if (*chptr != '/') {
        ddruidShowMessage(_("Bad Mount Point"), _("Ok"),
                    _("The mount point %s is illegal.\n\n"
		    "Mount points must begin with a leading /."), item);
        return 1;
    } 

    if (*(chptr + 1) && *(chptr + strlen(chptr) - 1) == '/') {
        ddruidShowMessage(_("Bad Mount Point"), _("Ok"),
                    _("The mount point %s is illegal.\n\n"
                      "Mount points may not end with a /."), item);
        return 1;
    } 

    while (*chptr && isprint(*chptr)) chptr++;

    if (*chptr) {
        ddruidShowMessage(_("Bad Mount Point"), _("Ok"),
                    _("The mount point %s is illegal.\n\n"
                    "Mount points may only printable characters."), item);
        return 1;
    }

    if (type != LINUX_NATIVE_PARTITION && (
         !strncmp(item, "/var", 4) ||
         !strncmp(item, "/tmp", 4) ||
         !strncmp(item, "/boot", 4) ||
         !strcmp(item, "/") ||
         !strncmp(item, "/root", 4))) {
        ddruidShowMessage(_("Bad Mount Point"), _("Ok"),
                    _("The mount point %s is illegal.\n\n"
                      "System partitions must be on Linux Native "
                      "partitions."), item);
        return 1;
    }

    if (type != LINUX_NATIVE_PARTITION &&
	type != NFS_REMOTE_PARTITION &&
        !strncmp(item, "/usr", 4)) {
        ddruidShowMessage(_("Bad Mount Point"), _("Ok"),
                    _("The mount point %s is illegal.\n\n"
                      "/usr must be on a Linux Native partition "
                      "or an NFS volume."), item);
        return 1;
    }

    return 0;
}

int newFseditContext (char ** drives,
		      struct fstab * fstab,
		      int flags,
		      FseditContext ** new)
{
    FseditContext * context;
    char ** deviceList;
    int numDrives;
    struct fstabEntry entry;
    int i, rc;

    *new = (FseditContext *) malloc (sizeof (FseditContext));
    context = *new;
    memset(context, 0, sizeof (FseditContext));

    numDrives = 0;
    for (i = 0; drives[i]; i++, numDrives++);

    if (numDrives >= MAX_HARDDRIVES) {
	ddruidShowMessage(_("Too Many Drives"), _("Ok"),
		  _("You have more drives than this program supports. "
		    "Please use the standard fdisk program to setup your "
		    "drives and please notify Red Hat Software that you "
		    "saw this message."));
	return INST_ERROR;
    }

    deviceList = createDevices(drives, numDrives);

    memset(context->hdarr, 0, MAX_HARDDRIVES * sizeof(HardDrive *));
    rc = ReadDrives(deviceList, numDrives, context->hdarr, &context->numhd, 0, 
		    flags & FSEDIT_READONLY, flags & FSEDIT_TESTING,
		    flags & FSEDIT_AUTOCLEARMBR);

    if (context->numhd < 1) {
	ddruidShowMessage(_("No Drives Found"), _("Ok"),
		  _("An error has occurred - no valid devices were found "
		    "on which to create new filesystems.  Please check "
		    "your hardware for the cause of this problem."));
	
	for (i = 0; i < numDrives; i++)
	    unlink(deviceList[i]);
	return INST_ERROR;
    }

    /* copy the fstab we were given */
    for (i = 0; i < fstab->numEntries; i++) {
	memset(&entry, 0, sizeof(entry));
	entry.device = strdup(fstab->entries[i].device);
	entry.mntpoint = strdup(fstab->entries[i].mntpoint);
	addFstabEntry(&context->fstab, entry);
    }

    /* make a prestine copy of the hdarr */
    for (i = 0; i < context->numhd; i++) {
	context->prestinehdarr[i] = (HardDrive *) malloc(sizeof(HardDrive));
	*context->prestinehdarr[i] = *context->hdarr[i];
    }

    /* make backup of hdarr if necessary before user mucked with it */
    /* copy original hard drive configurations into work spaces */
    for (i=0; i < context->numhd; i++) {
	context->newhdarr[i] = (HardDrive *) malloc(sizeof(HardDrive));
	*context->newhdarr[i] = *context->hdarr[i];
    }

    fdiskSetupPartitionSpec(context->hdarr, context->numhd, &context->spec );

    context->flags = flags;
    context->cbi.function = NULL;
    context->cbi.data = NULL;
    
    return INST_OKAY;
}

void delFseditContext (FseditContext * context)
{
    int i;
    
    freeFstab(context->fstab);
    
    for (i=0; i < context->numhd; i++)
	fdiskCloseDevice(context->hdarr[i]);

    for (i=0; i < context->numhd; i++)
	if (context->newhdarr[i])
	    free (context->newhdarr[i]);

    for (i=0; i < context->numhd; i++)
	if (context->prestinehdarr[i])
	    free (context->prestinehdarr[i]);

/*      removeDevices(deviceList, numDrives); */
}


void exitFsedit (FseditContext *context, struct raidInstance * raidInfo)
{
    struct repartitionInfo * repartInfo;
    int i, j;

    context->repartInfo = NULL;
    if (DisksChanged(context->prestinehdarr, context->hdarr, context->numhd)) {
	repartInfo = malloc(sizeof(*repartInfo));
	repartInfo->hdarr = context->hdarr;
	repartInfo->numDrives = context->numhd;
	context->repartInfo = repartInfo;
    }
    
    /* free up old fstab */
/*      freeFstab(context->fstab); */
    PartitionSpecToFstab(context->hdarr, context->numhd,
			 &context->spec, &context->fstab);
/*      MergeRemoteFSFstab( &remotefstab, fstab ); */
/*      freeFstab(remotefstab); */

    /* free old raid information, if any */
    if (context->raid) {
	i = 0;
	while (context->raid[i].mntpt) {
	    free(context->raid[i].mntpt);
	    free(context->raid[i].device);
	    j = 0;
	    while (context->raid[i].devices[j]) {
		free(context->raid[i].devices[j]);
		j++;
	    }
	    free(context->raid[i].devices);

	    i++;
	}
    }

    context->raid = raidInfo;
}

void FSEditInitialize(FseditContext * context) {
    setupGlobalContextEvenThoughYouShouldNeverUseGlobalVariables(context);
}

/* main program */
int FSEditPartitions(FseditContext *context) {
    struct fstab  remotefstab;
    int rc, ourrc = 0;
    static int beenManual = 0;
    int keepChanges = 0;
    static int where = 0;
    int dir;

    if (where == 0)
	dir = 1;
    else
	dir = -1;

    /* if they dont cancel it will be new fstab                  */
    remotefstab = copyRemoteFSFstab( &context->fstab ); 
    MergeFstabEntries( context->hdarr, context->numhd,
		       &context->spec, &context->fstab );
    
    if (1 || beenManual) {
	/* Goto master screen */
	rc = StartMaster(context,
			 &remotefstab, 
			 context->flags & FSEDIT_READONLY,
			 &keepChanges);
	if (rc == FDISK_ERR_USERABORT)
	    ourrc = INST_CANCEL;
	else if (rc) 
	    ourrc = INST_ERROR;
	else
	    ourrc = 0;
    }

    return ourrc;
}

int FSWritePartitions(char ** drives, void * partList) {
    struct repartitionInfo * repartInfo = partList;
    char ** deviceList;
    int numDrives;
    int rc = 0;
    int i, error = 0;

    numDrives = 0;
    for (i = 0; drives[i]; i++, numDrives++);
    deviceList = createDevices(drives, numDrives);
    if (!deviceList) return -1;

    for (i=0; i<repartInfo->numDrives; i++) {
	if (!error) 
	    if (repartInfo->hdarr[i]->write_f(repartInfo->hdarr[i])) {
		rc = i + 1;
		error = errno;
	    }
	fdiskCloseDeviceFd(repartInfo->hdarr[i]);
    }
    
    errno = error;
    return rc;
}

#define BALKAN_PART_DOS		1
#define BALKAN_PART_EXT2	2
#define BALKAN_PART_OTHER	3
#define BALKAN_PART_NTFS	4
#define BALKAN_PART_SWAP	5
#define BALKAN_PART_RAID	6
#define BALKAN_PART_UFS		7

partitionList * FSPartitionList(FseditContext *context) {
    int i;
    PartitionSpec * spec = &context->spec;
    partitionList * result = malloc(sizeof(partitionList) * (spec->num + 1));
    int num = 0;
    
    for (i=0; i<spec->num; i++) {
	if (spec->entry[i].partition.type.current == DOS_EXTENDED_PARTITION ||
	    spec->entry[i].partition.type.current == WIN98_EXTENDED_PARTITION)
	    continue;

	result[num].name = strdup(spec->entry[i].name);
	result[num].device = malloc(20);
	sprintf (result[num].device, "%s%d", 
		 context->hdarr[spec->entry[i].partition.drive.current - 1]->prefix,
		 spec->entry[i].partition.num.current);
	switch (spec->entry[i].partition.type.current) {
	case 0x01:
	case 0x04:
	case 0x06:
	case 0x0b:
	case 0x0c:
	case 0x0e:
	case 0x0f:
	    result[num].type = BALKAN_PART_DOS;
	    break;
	case 0x7:
	    result[num].type = BALKAN_PART_NTFS;
	    break;
	case 0x83:
	    result[num].type = BALKAN_PART_EXT2;
	    break;
	case 0x82:
	    result[num].type = BALKAN_PART_SWAP;
	    break;
	case 0xfd:
	    result[num].type = BALKAN_PART_RAID;
	    break;
	default:
	    result[num].type = BALKAN_PART_OTHER;
	    break;
	}
	num++;
    }

    result[num].device = NULL;

    return result;
}

int FSFreeState(void * partList) {
    struct repartitionInfo * repartInfo = partList;
    int i;

    for (i = 0; i < repartInfo->numDrives; i++) {
    	fdiskCloseDevice(repartInfo->hdarr[i]);
    }

    return 0;
}

/* read in the requested drives                                 */
/* pass an array of names of block devices, returns 0 if ok     */
int ReadDrives( char **drives, int numdrives,
		       HardDrive **hdarr, unsigned int *numhd, int forcezero, 
		       int readOnly, int testing, int autoClearMbr) {

    char errbody[250];
    int  i, done, status;
    char *ptr;
    
    /* loop over all specified block devices */
    *numhd = 0;
    for (i=0; i < numdrives; ) {
	status = fdiskOpenDevice(drives[i], *numhd+1, &hdarr[*numhd]);
	if (status != FDISK_SUCCESS) {

	  /* HORRIBLE HACK               XXX*/

#ifdef __sparc__
	  if (status == FDISK_ERR_CORRUPT) { /* bad Sun disklabel */
	    snprintf(errbody, sizeof(errbody),
		     _("A disk with a corrupt Sun disklabel has been "
		       "found while reading block device %s.  You must "
                       "use fdisk to create and write a new label to "
		       "this device."), drives[i]);
	    if (ddruidYesNo(_("Corrupt Sun disklabel"),
			    _("Back"), _("Skip Drive"), errbody, 0) == 1)
	      return INST_CANCEL;
	    else {
	      i++;
		continue;
	    }
	  }
#endif
	    snprintf(errbody, sizeof(errbody),
		     _("An error occurred reading the partition table for the "
		       "block device %s.  The error was"), drives[i]);
	    if (HandleFdiskError( status, errbody, "Retry", "Skip Drive" ))
		continue;
	    else {
		i++;
		continue;
	    }
	} else {
	    done = 0;

	    /* set up drive prefix */
	    if ((ptr = (strstr(hdarr[*numhd]->name, "tmp/")))) {
		strcpy(hdarr[*numhd]->prefix, ptr + 4);
	    }
	    /* for RAID arrays of format c0d0p1 */
	    if (strstr(ptr + 4, "rd/") || strstr(ptr + 4, "ida/"))
		strcat(hdarr[*numhd]->prefix, "p");
	    
	    while (!done) {
		status = fdiskReadPartitions( hdarr[*numhd] );
		if (status != FDISK_SUCCESS) {
		    int rc;
		    
		    if (status == FDISK_ERR_BADMAGIC) {
			if (forcezero) {
			    if (!testing)
				#ifdef sparc
				    fdiskInitSunLabel(hdarr[*numhd]);
				#else
				    fdiskZeroMBR(hdarr[*numhd]);
				#endif
			    fdiskCloseDevice(hdarr[*numhd]);
			    done = 1;
			} else {
			    char text[200];

			    if (autoClearMbr) {
				rc = 1;
			    } else {
				sprintf(text,
				   _("The partition table on device %s is "
				     "corrupted.  To create new partitions "
				     "it must be initialized,"
				     " causing the loss of ALL DATA on "
				     "this drive."), drives[i]+5);
				rc = ddruidYesNo(_("Bad Partition Table"),
					 _("Initialize"), _("Skip Drive"), 
					 text, 0);
			    }
			    
			    if (rc == 1) {
				if (!testing)
				    #ifdef sparc
					fdiskInitSunLabel(hdarr[*numhd]);
				    #else
					fdiskZeroMBR(hdarr[*numhd]);
				    #endif
				fdiskCloseDevice(hdarr[*numhd]);
				done = 1;
			    } else {
				i++;
				fdiskCloseDevice(hdarr[*numhd]);
				done = 1;
			    }
			}
		    } else {			
			snprintf(errbody, sizeof(errbody),
			 _("An error occurred reading the partition table "
			   "for the block device %s.  The error was"),
				 drives[i]+5);
			if (HandleFdiskError(status,errbody,
					     _("Retry"), _("Skip Drive"))){
			    fdiskCloseDevice(hdarr[*numhd]);
			    done = 1;
			} else {
			    i++;
			    fdiskCloseDevice(hdarr[*numhd]);
			    done = 1;
			}
		    }
		/* THIS IS A HORRIBLE NASTY HACK */
		#ifdef __alpha__
		} else if (hdarr[i]->limits.maxPrimary > 4 && !readOnly) {
		    ddruidShowMessage(_("BSD Disklabel"), _("Ok"), _("A disk with "
				"a BSD disklabel has been found. The Red Hat "
				"installation only supports BSD Disklabels in "
				"read-only mode, so you must use a custom install "
				"and fdisk (instead of Disk Druid) for "
				"machines with BSD Disklabels."));
		    return INST_CANCEL;
		#endif
		} else {
		    *numhd += 1;
		    i++;
		    done = 1;
		}
	    }
	}
    }

    return FDISK_SUCCESS;
    
}
		
static int HandleFdiskError( int status, char *errbody, char *y, char *n ) {
    char errmsg[250];
    char yesmsg[]="Yes";
    char nomsg[] ="No";
    
    if (status < 0) {
	if (errno < sys_nerr-1)
	    strncpy(errmsg,sys_errlist[errno],sizeof(errmsg));
	else
	    snprintf(errmsg,sizeof(errmsg), _("System error %d"), errno);
    } else {
	if (status < fdisk_nerr)
	    strcpy(errmsg, fdisk_errlist[status]);
	else
	    snprintf(errmsg,sizeof(errmsg), "libfdisk error %d",errno);
    }

    if (y != NULL && n != NULL)
	return ErrorDialog( _("Fdisk Error"), errbody, errmsg, y, n);
    else
	return ErrorDialog( _("Fdisk Error"), errbody,errmsg,yesmsg,nomsg);
}

/* handles standard fdisk type errors */
/* returns non-zero if user picked "yes" response, and zero if "no" */
static int ErrorDialog(char *title, char *errbody, char *errmsg,
		       char *yesmsg, char *nomsg) {

    char *buf;

    /* I don't know if this is what msf intended, but it is a whole lot 
       easier. */
    buf = alloca(strlen(errbody)+strlen(errmsg) + 10);
    sprintf(buf, "%s: %s", errbody, errmsg);
    return ddruidYesNo(title, yesmsg, nomsg, buf, 0);
}