/***************************************************************************
mondo-prep.c  -  description
-----------------

begin: Fri Apr 19 16:40:35 EDT 2002
copyright : (C) 2002 Mondo  Hugo Rabson
email     : Hugo Rabson <hugorabson@msn.com>
edited by : by Stan Benoit 4/2002
email     : troff@nakedsoul.org
cvsid     : $Id: mondo-prep.c 30 2005-09-28 23:32:28Z bcornec $
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

/* mondo-prep.c             Hugo Rabson



07/20
- when starting RAID, don't do it twice :)
- moved Joshua's new get_phys_size_of_drive() code
  from resize_drive... into get_phys_size_of_drive()

06/29
- make sure software RAID devices are formatted IF user says they're to be
- drivelist is struct now, not char[][]

06/26
- drop make_relevant_partition_bootable(); do it yourself in C (mostly)
- offer to reboot if partition table is locked up by the kernel

06/22
- be sure not to resize non-NTFS images when restoring
- set non-NTFS images' partition types properly

06/19
- shut down all LVMs and VGs before prepping

05/07
- usage of parted2fdisk instead of fdisk alone (ia32/ia64 compatibility)
  BCO

03/31
- rewrote partitioning and formatting code to call fdisk once per disk

10/21/2003
- suspend/resume Newt gui before/after calling do_my_funky_lvm_stuff()

10/20
- rewrote format_everything() - what a mess it was.
  It now does things in three phases:-
  - formats software RAID devices (/dev/md0, etc.)
  - formats and configures LVM devices
  - formats regular partitions (/dev/hda1, /dev/sdb2, etc.) 
    and any LVMs recently prepped

10/07
- use strstr(format, "raid") instead of strcmp(format,"raid") to determin
  if partition is a RAID component

09/23
- better comments

09/18
- better logging of RAID activity

05/05
- added Joshua Oreman's FreeBSD patches

04/30
- added textonly mode

04/24
- added lots of assert()'s and log_OS_error()'s

04/21
- format_everything() --- don't let bar go too far
- mkfs -c to check for bad blocks when formatting

04/04
- misc clean-up (Tom Mortell)

01/15/2003
- added code for LVM and SW Raid (Brian Borgeson)

12/10/2002
- line 1238: friendlier output

11/20
- when wiping a given device in preparation for partitioning + formatting
  it, don't wipe the MBR; just the partition table. That allows for
  stupid-ass Compaq users who like to play with their MBR's.
- disable mountlist.txt-->mountlist.txt.pre-resize copying (superfluous)

09/09
- run_program_and_log_output() now takes boolean operator to specify
  whether it will log its activities in the event of _success_

07/01 - 07/31
- added hooks to libmondo
- RAID enhancements (Philippe de Muyter)

01/01 - 03/31
- partition_device() will refuse to partition /dev/mdX now (cos it's a
  virtual drive); however, it will return 0 (i.e. not an error)
- make_list_of_drives() will exclude /dev/md* from list
- mkreiserfs -ff instead of -q (Andy Glass)
- don't resize drive if drive not found (or if its size cannot be det'd)
- when generating list of drives from mountlist, skip the 'p' at the end
  of drive name if /dev/ida/ or /dev/cciss/; just do it (Michael Eisenberg)
- don't specify journal size when formatting ext3
  (used to have -Jsize=10 in the call to mkfs)
- handles files >2GB in size
- format interactively, if Interactive Mode
- removed reference to g_tape_size
- when executing /tmp/i-want-my-lvm, only record the error# if the command
  was _not_ an 'insmod' command
- pass partition size to fdisk in Kilobytes now, not Megabytes
- log fdisk's output to /tmp/mondo-restore.log if it fails
- don't try to format partitions of type 'image'
- don't type to set types of 'image' partitions
- if format code is 1 or 2 chars then assume it is a hex string
- took out all '/ /' comments
- don't extrapolate/add partition from RAID dev to mountlist if it's already
  present in mountlist
- less repetitive logging in the event of vacuum-packing of last part'n
- no extrapolation at all: RAID partitions should be listed in mountlist
  already, thanks to either Mindi v0.5x or the mountlist editor itself
- no longer say, 'and logging to...' when setting a partition's type
- don't run mkfs on RAID partitions (/dev/hd*, /dev/sd*); just set type
- the setting of a partition's type now takes place in a separate subroutine
  from the subroutine that actually creates the partition
- no need to set type if 83: 83 is the default (under fdisk)
- turned on '-Wall'; cleaned up some cruft
- if vacuum-packing partition (i.e. size=0MB --> max) then say, "(maximum)"
  not, "(0 MB)"

11/22/2001
- preliminary code review
- created on Nov 22nd, 2001
*/

/**
 * @file
 * Functions for prepping hard drives: partitioning, formatting, etc.
 */


#include "../common/my-stuff.h"
#include "../common/mondostructures.h"
#include "mondoprep.h"
#include "../common/libmondo.h"
#include "mondo-rstr-tools-EXT.h"
#include <sys/ioctl.h>
#include <linux/hdreg.h>
#include <math.h>


#define FDISK_LOG "/tmp/fdisk.log"

#ifdef __FreeBSD__
#define DKTYPENAMES
#define FSTYPENAMES
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <err.h>
#include <libgen.h>
#define OSSWAP(x,y) y
#else
#define OSSWAP(x,y) x
#endif

#define ARCHIVES_PATH MNT_CDROM"/archives"
#define MONDO_WAS_HERE "MONDOWOZEREMONDOWOZEREMONDOWOZEREhahahaMOJOJOJO"

//static char cvsid[] = "$Id: mondo-prep.c 30 2005-09-28 23:32:28Z bcornec $";

extern char *g_mountlist_fname;
extern long g_current_progress, g_maximum_progress;

extern bool g_text_mode;

extern void pause_for_N_seconds(int, char*);


FILE *g_fprep=NULL;



int g_partition_table_locked_up=0;










void wipe_MBRs_and_reboot_if_necessary(struct mountlist_itself *mountlist)
{
    char *command;
    char *tmp;
    int lino;
    int i;
    FILE*fout;
    char *buf;
    const int blocksize=512;        
        struct list_of_disks *drivelist=NULL;
// If LVMs are present and a zero-and-reboot wasn't recently undertaken
// then zero & insist on reboot.
    malloc_string(command);
    malloc_string(tmp);
    buf = malloc(blocksize);
        if (does_file_exist("/tmp/i-want-my-lvm")) // FIXME - cheating :)
	  {
	    drivelist = malloc(sizeof(struct list_of_disks));
	    make_list_of_drives_in_mountlist(mountlist, drivelist);
	    for (lino = 0; lino < drivelist->entries; lino++)
	      {
	        sprintf(command, "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"", drivelist->el[lino].device, MONDO_WAS_HERE);
	        if (!run_program_and_log_output(command, 1))
		  {
		    log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)", lino, drivelist->el[lino].device);
		    break;
		  }
              }
	    
	    if (lino==drivelist->entries)
	      {
// zero & reboot
	        log_to_screen("I am sorry for the inconvenience but I must ask you to reboot.");
		log_to_screen("I need to reset the Master Boot Record; in order to be");
		log_to_screen("sure the kernel notices, I must reboot after doing it.");
		log_to_screen("Please hit 'Enter' to reboot.");
	        for (lino = 0; lino < drivelist->entries; lino++)
	          {
		    for(i=0;i<blocksize; i++)
		      { buf[i] = 0; }
		    sprintf(buf, "%s\n", MONDO_WAS_HERE);
		    fout = fopen(drivelist->el[lino].device, "w+");
		    if (!fout)
		      {
		        log_msg(1, "Unable to open+wipe %s", drivelist->el[lino].device);
		      }
		    else
		      {
		        if (1!=fwrite(buf, blocksize, 1, fout))
			  {
			    log_msg(1, "Failed to wipe %s", drivelist->el[lino].device);
			  }
			else
			  {
			    log_msg(1, "Successfully wiped %s", drivelist->el[lino].device);
			  }
		        fclose(fout);
	              }
		  }
                system("sync"); system("sync"); system("sync");
		popup_and_OK("I must now reboot. Please leave the boot media in the drive and repeat your actions - e.g. type 'nuke' - and it should work fine.");
                system("reboot"); 
	      }
          }
	  
// Still here? Cool!
  paranoid_free(command);
  paranoid_free(tmp);
  log_msg(1, "Cool. I didn't have to wipe anything.");
}






int fput_string_one_char_at_a_time(FILE*fout, char*str)
{
  int i, j;
  FILE*fq;

  if (ferror(fout))
    {
	return(-1);
    }
  log_msg(5, "Writing string '%s', one char at a time", str);
  j = strlen(str);
  for(i=0; i<j; i++)
    {
      log_msg(6, "Writing %d ('%c')", str[i], str[i]);
      if ((fq = fopen(FDISK_LOG, "a+"))) { fputc(str[i], fq);fclose(fq); }
      fputc(str[i], fout);
      fflush(fout);
      usleep(1000L*100L);
      if (str[i]<32) { usleep(1000L*10L); }
    }
  log_msg(5, "Returning");
   
   return(i);
}










/**
 * @addtogroup prepGroup
 * @{
 */
/**
 * Execute the commands in /tmp/i-want-my-lvm.
 * These should probably be commands to set up LVM.
 * @return The number of errors encountered (0 for success).
 */
 

int do_my_funky_lvm_stuff(bool just_erase_existing_volumes, bool vacuum_pack)
{
	/**  buffers **********************************************/
	char *tmp;
	char *incoming;
	char *command;
	char *lvscan_sz;
	char *lvremove_sz;
	char *pvscan_sz;
	char *vgscan_sz;
	char *vgcreate_sz;
	char *vgchange_sz;
	char *vgremove_sz;
//	char *do_this_last;

	/** char **************************************************/
	char *p;
	char *q;

	/** int ***************************************************/
	int retval = 0;
	int res = 0;
	int i;
	int lvmversion = 1;
	long extents;
	fpos_t orig_pos;
	
	/** pointers **********************************************/
	FILE *fin;

	/** end *****************************************************/

#ifdef __FreeBSD__
	return (0);
#endif

	if (!(fin = fopen("/tmp/i-want-my-lvm", "r"))) {
		log_OS_error("/tmp/i-want-my-lvm");
		return (1);
	}

	malloc_string(tmp);
	malloc_string(incoming);
	malloc_string(lvscan_sz);
	malloc_string(lvremove_sz);
	malloc_string(vgscan_sz);
	malloc_string(pvscan_sz);
	malloc_string(vgcreate_sz);
	malloc_string(vgchange_sz);
	malloc_string(vgremove_sz);
//	malloc_string(do_this_last); // postpone lvcreate call if necessary
	command = malloc(512);

//	do_this_last[0] = '\0';
iamhere("STARTING");
	log_msg(1, "OK, opened i-want-my-lvm. Shutting down LVM volumes...");
	if (find_home_of_exe("lvm")) // found it :) cool
	  {
	    strcpy(lvscan_sz,   "lvm lvscan");
	    strcpy(lvremove_sz, "lvm lvremove");
	    strcpy(vgscan_sz,   "lvm vgscan");
	    strcpy(pvscan_sz,   "lvm pvscan");
	    strcpy(vgcreate_sz, "lvm vgcreate");
	    strcpy(vgchange_sz, "lvm vgchange");
	    strcpy(vgremove_sz, "lvm vgremove");
	  }
	else
	  {
	    strcpy(lvscan_sz,   "lvscan");
	    strcpy(lvremove_sz, "lvremove");
	    strcpy(vgscan_sz,   "vgscan");
	    strcpy(pvscan_sz,   "pvscan");
	    strcpy(vgcreate_sz, "vgcreate");
	    strcpy(vgchange_sz, "vgchange");
	    strcpy(vgremove_sz, "vgremove");
	  }
	sprintf(command, "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> " MONDO_LOGFILE "; %s -f $i; done",
					lvscan_sz, lvremove_sz);
	run_program_and_log_output(command, 5);
	sleep(1);
	sprintf(command, "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> " MONDO_LOGFILE "; done; %s -a n", vgscan_sz, vgchange_sz, vgremove_sz, vgremove_sz);
	run_program_and_log_output(command, 5);
	if (just_erase_existing_volumes) {
		paranoid_fclose(fin);
		log_msg(1, "Closed i-want-my-lvm. Finished erasing LVMs.");
		retval=0;
		goto end_of_i_want_my_lvm;
	}

	log_msg(1, "OK, rewound i-want-my-lvm. Doing funky stuff...");
	rewind(fin);
	for (fgets(incoming, 512, fin); !feof(fin); fgets(incoming, 512, fin)) {
		fgetpos(fin, &orig_pos);
		if (incoming[0] != '#') {
			continue;
		}
		if (res && strstr(command, "create") && vacuum_pack)
		  {
		    sleep(2);
		    system("sync"); system("sync"); system("sync");
		  }
		if ((p=strstr(incoming, "vgcreate")))
		  {
// include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
		    for (fgets(tmp, 512, fin); !feof(fin); fgets(tmp, 512, fin)) {
			if (tmp[0] == '#') {
			    fsetpos(fin, &orig_pos);
			    break;
			} else {
			    fgetpos(fin, &orig_pos);
			    strcat(incoming, tmp);
			}
		    }
		    for(q=incoming; *q!='\0'; q++)
		      {
		        if (*q<32) { *q=' '; }
		      }
		    strcpy(tmp, p+strlen("vgcreate")+1);
		    for(q=tmp; *q>32; q++);
		    *q = '\0';
		       log_msg(1, "Deleting old entries at /dev/%s", tmp);
//		       sprintf(command, "%s -f %s", vgremove_sz, tmp);
//		       run_program_and_log_output(command, 1);
		       sprintf(command, "rm -Rf /dev/%s", tmp);
		       run_program_and_log_output(command, 1);
		    run_program_and_log_output(vgscan_sz, 1);
		    run_program_and_log_output(pvscan_sz, 1);
		    log_msg(3, "After working around potentially broken i-want-my-lvm, incoming[] is now '%s'", incoming);
		  }
		for (p = incoming + 1; *p == ' '; p++);
		strcpy(command, p);
		for (p = command; *p != '\0'; p++);
		for (; *(p - 1) < 32; p--);
		*p = '\0';
		res = run_program_and_log_output(command, 5);
		if (res>0 && (p=strstr(command, "lvm ")))
		  {
		    *p = *(p+1) = *(p+2) = ' ';
		    res = run_program_and_log_output(command, 5);
		  }
		log_msg(0, "%s --> %d", command, res);
                if (res>0) {res=1;}
		if (res && strstr(command, "lvcreate") && vacuum_pack)
		  {
		    res=0;
		    if (strstr(command, "lvm lvcreate"))
			lvmversion = 2;
		    log_it("%s... so I'll get creative.", tmp);
		    if (lvmversion == 2)
		      {
		        strcpy(tmp, call_program_and_get_last_line_of_output
		    	    ("cat /var/log/mondo-archive.log | tail -n5 | grep Insufficient | tail -n1"));
		      }
		    else
		      {
		        strcpy(tmp, call_program_and_get_last_line_of_output
		    	    ("cat /var/log/mondo-archive.log | tail -n5 | grep lvcreate | tail -n1"));
		      }
		    for(p=tmp; *p!='\0' && !isdigit(*p); p++);
		    extents = atol(p);
		    log_msg(5, "p='%s' --> extents=%ld", p, extents);
		    p = strstr(command, "-L");
		    if (!p)
		      {
		        log_msg(0, "Fiddlesticks. '%s' returned %d", command, res);
		      }
		    else
		      {
			if (lvmversion == 2)
			  {
			    *p++ = '-'; *p++ = 'l'; *p++ = ' ';
			    for(q=p; *q!=' '; q++) { *q = ' '; }
			    sprintf(p, "%ld", extents);
			    i = strlen(p);
			    *(p+i) = ' ';
			  }
			else
			  {
			    p++; p++; p++;
			    for(q=p; *q!=' '; q++) { *(q-1) = ' '; }
			    sprintf(p, "%ld%c", extents, 'm');
			    i = strlen(p);
			    *(p+i) = ' ';
			  }
		        log_msg(5, "Retrying with '%s'", command);
		        res = run_program_and_log_output(command, 5);
			if (res>0) { res=1; }
			if (g_fprep) { fprintf(g_fprep, "%s\n", command); }
		        log_msg(0, "%s --> %d", command, res);
			if (!res)
			  {
			    log_msg(5, "YAY! This time, it succeeded.");
			  }
		      }
		  }
		if (strstr(command, "vgcreate"))
		  {
		    log_msg(0, "In case you're interested...");
		    run_program_and_log_output(vgscan_sz, 1);
		    run_program_and_log_output(pvscan_sz, 1);
		  }
                if (res!=0 && !strstr(command, "insmod")) {
			retval ++;
		}
		sprintf(tmp, "echo \"%s\" >> /tmp/out.sh", command);
		system(tmp);
		sleep(1);
	}
	paranoid_fclose(fin);
	log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
end_of_i_want_my_lvm:
	paranoid_free(tmp);
	paranoid_free(incoming);
	paranoid_free(command);
	paranoid_free(lvscan_sz);
	paranoid_free(lvremove_sz);
	paranoid_free(vgscan_sz);
	paranoid_free(pvscan_sz);
	paranoid_free(vgcreate_sz);
	paranoid_free(vgchange_sz);
	paranoid_free(vgremove_sz);
//	paranoid_free(do_this_last);
	system("sync"); system("sync"); system("sync"); 
	sleep(1);
iamhere("ENDING");
	if (retval>2)
	  {
	    log_msg(1, "%d errors. I'm reporting this.", retval);
	    return(retval);
	  }
	else
	  {
	    log_msg(1, "Not many errors. Returning 0.");
	    return(0);
	  }
}


/**
 * Add RAID partitions while copying @p old_mountlist to @p new_mountlist.
 * We go through @p old_mountlist and check if any RAID device (/dev/md? on Linux)
 * is in it; if it is, then we put the disks contained within that RAID device
 * into the mountlist as well.
 * @param old_mountlist The mountlist to read.
 * @param new_mountlist The mountlist to write, with the RAID partitions added.
 * @return 0 for success, nonzero for failure.
 */
	int extrapolate_mountlist_to_include_raid_partitions(struct mountlist_itself
						     *new_mountlist, struct mountlist_itself
						     *old_mountlist)
{
	/** pointers *********************************************************/
	FILE *fin;

	/** int **************************************************************/
	int lino;
	int j;

	/** buffers **********************************************************/
	char *incoming;
	char *tmp;

	/** pointers *********************************************************/
	char *p;

	/** init *************************************************************/
	new_mountlist->entries = 0;

	/** end **************************************************************/

	malloc_string(incoming);
	malloc_string(tmp);
	assert(new_mountlist != NULL);
	assert(old_mountlist != NULL);

#ifdef __FreeBSD__
	log_to_screen ("I don't know how to extrapolate the mountlist on FreeBSD. Sorry.");
	return(1);
#endif

	for (lino = 0; lino < old_mountlist->entries; lino++) {
		if (strstr(old_mountlist->el[lino].device, RAID_DEVICE_STUB))	// raid
		{
			if (!does_file_exist("/etc/raidtab")) {
				log_to_screen("Cannot find /etc/raidtab - cannot extrapolate the fdisk entries");
				finish(1);
			}
			if (!(fin = fopen("/etc/raidtab", "r"))) {
				log_OS_error("Cannot open /etc/raidtab");
				finish(1);
			}
			for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
			     && !strstr(incoming, old_mountlist->el[lino].device); fgets(incoming, MAX_STR_LEN - 1, fin));
			if (!feof(fin)) {
				sprintf(tmp, "Investigating %s", old_mountlist->el[lino].device);
				log_it(tmp);
				for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
				     && !strstr(incoming, "raiddev"); fgets(incoming, MAX_STR_LEN - 1, fin)) {
					if (strstr(incoming, OSSWAP("device", "drive"))
					    && !strchr(incoming, '#')) {
						for (p = incoming + strlen(incoming); *(p - 1) <= 32; p--);
						*p = '\0';
						for (p--; p > incoming && *(p - 1) > 32; p--);
						sprintf(tmp, "Extrapolating %s", p);
						log_it(tmp);
						for (j = 0; j < new_mountlist->entries && strcmp(new_mountlist->el[j].device, p);
						     j++);
						if (j >= new_mountlist->entries) {
							strcpy(new_mountlist->el[new_mountlist->entries].device, p);
							strcpy(new_mountlist->el[new_mountlist->entries].mountpoint, "raid");
							strcpy(new_mountlist->el[new_mountlist->entries].format, "raid");
							new_mountlist->el[new_mountlist->entries].size =
							    old_mountlist->el[lino].size;
							new_mountlist->entries++;
						} else {
							sprintf(tmp, "Not adding %s to mountlist: it's already there", p);
							log_it(tmp);
						}
					}
				}
			}
			paranoid_fclose(fin);
		} else {
			strcpy(new_mountlist->el[new_mountlist->entries].device, old_mountlist->el[lino].device);
			strcpy(new_mountlist->el[new_mountlist->entries].mountpoint, old_mountlist->el[lino].mountpoint);
			strcpy(new_mountlist->el[new_mountlist->entries].format, old_mountlist->el[lino].format);
			new_mountlist->el[new_mountlist->entries].size = old_mountlist->el[lino].size;
			new_mountlist->entries++;
		}
	}
	paranoid_free(incoming);
	paranoid_free(tmp);

	return (0);
}


/**
 * Format @p device as a @p format filesystem.
 * This will use the format command returned by which_format_command_do_i_need().
 * If @p device is an LVM PV, it will not be formatted, and LVM will be started
 * (if not already done). If it's an imagedev, software RAID component, or
 * (under BSD) swap partition, no format will be done.
 * @param device The device to format.
 * @param format The filesystem type to format it as.
 * @return 0 for success, nonzero for failure.
 */
int format_device(char *device, char *format)
{
	/** int **************************************************************/
	int res;
	int retval = 0;
#ifdef __FreeBSD__
	static bool vinum_started_yet = FALSE;
#endif

	/** buffers ***********************************************************/
	char *program;
	char *tmp;

	/** end ****************************************************************/

	malloc_string(program);
	malloc_string(tmp);
	assert_string_is_neither_NULL_nor_zerolength(device);
	assert(format != NULL);

	if (strstr(format, "raid")) {	// do not form RAID disks; do it to /dev/md* instead
		sprintf(tmp, "Not formatting %s (it is a RAID disk)", device);
		log_it(tmp);
		paranoid_free(program); paranoid_free(tmp);
		return (0);
	}
#ifdef __FreeBSD__
	if (strcmp(format, "swap") == 0) {
		log_it("Not formatting %s - it's swap", device);
		paranoid_free(program); paranoid_free(tmp);
		return (0);
	}
#endif
	if (strlen(format) <= 2) {
		sprintf(tmp,
			"%s has a really small format type ('%s') - this is probably a hexadecimal string, which would suggest the partition is an image --- I shouldn't format it",
			device, format);
		log_it(tmp);
		paranoid_free(program); paranoid_free(tmp);
		return (0);
	}
	if (is_this_device_mounted(device)) {
		sprintf(tmp, "%s is mounted - cannot format it       ", device);
		log_to_screen(tmp);
		paranoid_free(program); paranoid_free(tmp);
		return (1);
	}
	if (strstr(device, RAID_DEVICE_STUB)) {
		newtSuspend();
#ifdef __FreeBSD__
		if (!vinum_started_yet) {
			if (!does_file_exist("/tmp/raidconf.txt")) {
				log_to_screen("/tmp/raidconf.txt does not exist. I therefore cannot start Vinum.");
			} else {
				int res;
				res = run_program_and_log_output("vinum create /tmp/raidconf.txt", TRUE);
				if (res) {
					log_to_screen
					    ("`vinum create /tmp/raidconf.txt' returned errors. Please fix them and re-run mondorestore.");
					finish(1);
				}
				vinum_started_yet = TRUE;
			}
		}

		if (vinum_started_yet) {
			FILE *fin;
			char line[MAX_STR_LEN];
			sprintf(tmp, "Initializing Vinum device %s (this may take a *long* time)", device);
			log_to_screen(tmp);
			/* format raid partition */
			//      sprintf (program, "mkraid --really-force %s", device); --- disabled -- BB, 02/12/2003
			sprintf(program,
				"for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes",
				basename(device));
			system(program);
			if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
			fin = fopen("/tmp/plexes", "r");
			while (fgets(line, MAX_STR_LEN - 1, fin)) {
				if (strchr(line, '\n'))
					*(strchr(line, '\n')) = '\0';	// get rid of the \n on the end

				sprintf(tmp, "Initializing plex: %s", line);
				open_evalcall_form(tmp);
				sprintf(tmp, "vinum init %s", line);
				system(tmp);
				while (1) {
					sprintf(tmp,
						"vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'",
						line);
					FILE *pin = popen(tmp, "r");
					char status[MAX_STR_LEN / 4];
					fgets(status, MAX_STR_LEN / 4 - 1, pin);
					pclose(pin);

					if (!strcmp(status, "up")) {
						break;	/* it's done */
					}
					update_evalcall_form(atoi(status));
					usleep(250000);
				}
				close_evalcall_form();
			}
			fclose(fin);
			unlink("/tmp/plexes");
			/* retval+=res; */
		}
#else
		sprintf(tmp, "Initializing RAID device %s", device);
		log_to_screen(tmp);

// Shouldn't be necessary.
		log_to_screen("Stopping %s", device);
		stop_raid_device(device);
		system("sync"); sleep(1);
		if (g_fprep) { fprintf(g_fprep, "%s\n", program); }

		log_msg(1, "Making %s", device);
		sprintf(program, "mkraid --really-force %s", device);
		res = run_program_and_log_output(program, 1);
		log_msg(1, "%s returned %d", program, res);
		system("sync"); sleep(3);
		start_raid_device(device);
		if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
		system("sync"); sleep(2);
		
//		log_to_screen("Starting %s", device);
//		sprintf(program, "raidstart %s", device);
//		res = run_program_and_log_output(program, 1);
//		log_msg(1, "%s returned %d", program, res);
//		system("sync"); sleep(1);
		if (g_fprep) { fprintf(g_fprep, "%s\n", program); }

#endif
		system("sync"); sleep(1);
		newtResume();
	}
//#ifndef __FreeBSD__
//#endif

	if (!strcmp(format, "lvm"))
	  {
	    log_msg(1, "Don't format %s - it's part of an lvm volume", device);
	    paranoid_free(program); paranoid_free(tmp);
	    return(0);
	  }
	res = which_format_command_do_i_need(format, program);
	sprintf(tmp, "%s %s", program, device);
	if (strstr(program, "kludge")) {
		strcat(tmp, " /");
	}
	sprintf(program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
	sprintf(tmp, "Formatting %s as %s", device, format);
	update_progress_form(tmp);
	res = run_program_and_log_output(program, FALSE);
	if (res && strstr(program, "kludge")) {
		sprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s", format, device);
#ifdef __FreeBSD__
		sprintf(program, "newfs_msdos -F 32 %s", device);
#else
		sprintf(program, "mkfs -t %s -F 32 %s", format, device);
#endif
		res = run_program_and_log_output(program, FALSE);
		if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
	}
	retval += res;
	if (retval) {
		strcat(tmp, "...failed");
	} else {
		strcat(tmp, "...OK");
	}

	log_to_screen(tmp);
	paranoid_free(program); paranoid_free(tmp);
	system("sync"); sleep(1);
	return (retval);
}





/**
 * Format all drives (except those excluded by format_device()) in @p mountlist.
 * @param mountlist The mountlist containing partitions to be formatted.
 * @param interactively If TRUE, then prompt the user before each partition.
 * @return The number of errors encountered (0 for success).
 */
int format_everything(struct mountlist_itself *mountlist, bool interactively)
{
	/** int **************************************************************/
	int retval = 0;
	int lino;
	int res;
//	int i;
//	struct list_of_disks *drivelist;

	/** long *************************************************************/
	long progress_step;

	/** bools ************************************************************/
	bool do_it;

	/** buffers **********************************************************/
	char *tmp;

	/** pointers *********************************************************/
	struct mountlist_line *me;	// mountlist entry
	/** end **************************************************************/

	assert(mountlist!=NULL);
	malloc_string(tmp);
	sprintf(tmp, "format_everything (mountlist, interactively = %s", (interactively) ? "true" : "false");
	log_it(tmp);
	mvaddstr_and_log_it(g_currentY, 0, "Formatting partitions     ");
	open_progress_form("Formatting partitions", "I am now formatting your hard disk partitions.",
			   "This may take up to five minutes.", "", mountlist->entries + 1);

	progress_step = (mountlist->entries > 0) ? g_maximum_progress / mountlist->entries : 1;
// start soft-raids now (because LVM might depend on them)
// ...and for simplicity's sake, let's format them at the same time :)
	log_msg(1, "Stopping all RAID devices");
	stop_all_raid_devices(mountlist);
	system("sync"); system("sync"); system("sync"); 
	sleep(2);
	log_msg(1, "Prepare soft-RAIDs"); // prep and format too
	for (lino = 0; lino < mountlist->entries; lino++) {
		me = &mountlist->el[lino];	// the current mountlist entry
		log_msg(2, "Examining %s", me->device);
		if (!strncmp(me->device, "/dev/md", 7)) {
			if (interactively) {
				// ask user if we should format the current device
				sprintf(tmp, "Shall I format %s (%s) ?", me->device, me->mountpoint);
				do_it = ask_me_yes_or_no(tmp);
			} else {
				do_it = TRUE;
			}
			if (do_it) {
			// NB: format_device() also stops/starts RAID device if necessary
				retval += format_device(me->device, me->format);
			}
			g_current_progress += progress_step;
		}
	}
	system("sync"); system("sync"); system("sync"); 
	sleep(2);
// This last step is probably necessary
//	log_to_screen("Re-starting software RAIDs...");
//	start_all_raid_devices(mountlist);
//	system("sync"); system("sync"); system("sync"); 
//	sleep(5);
// do LVMs now
	log_msg(1, "Creating LVMs");
	if (does_file_exist("/tmp/i-want-my-lvm")) {
		wait_until_software_raids_are_prepped("/proc/mdstat", 10);
		log_to_screen("Configuring LVM");
                if (!g_text_mode) { newtSuspend(); }
/*
		for(i=0; i<3; i++)
		  {
		    res = do_my_funky_lvm_stuff(FALSE, FALSE);
		    if (!res) { break; }
		    sleep(3);
		    res = do_my_funky_lvm_stuff(TRUE, FALSE);
		    sleep(3);
		  }
		if (res) {
			log_msg(1, "Vacuum-packing...");
*/
			res = do_my_funky_lvm_stuff(FALSE, TRUE);
/*
		}
*/
                if (!g_text_mode) { newtResume(); }
		if (!res) { log_to_screen("LVM initialized OK"); }
		else { log_to_screen("Failed to initialize LVM"); }
		// retval += res;
		if (res) {
			retval ++;
		}
	    sleep(3);
	}

// do regulars at last
	sleep(2); // woo!
        log_msg(1, "Formatting regulars");
	for (lino = 0; lino < mountlist->entries; lino++) {
		me = &mountlist->el[lino];	// the current mountlist entry
		if (!strcmp(me->mountpoint, "image")) {
			sprintf(tmp, "Not formatting %s - it's an image", me->device);
			log_it(tmp);
		} else if (!strcmp(me->format, "raid")) {
			sprintf(tmp, "Not formatting %s - it's a raid-let", me->device);
			log_it(tmp);
			continue;
		} else if (!strcmp(me->format, "lvm")) {
			sprintf(tmp, "Not formatting %s - it's an LVM", me->device);
			log_it(tmp);
			continue;
		} else if (!strncmp(me->device, "/dev/md", 7)) {
			sprintf(tmp, "Already formatted %s - it's a soft-RAID dev", me->device);
			log_it(tmp);
			continue;
		} else if (!does_file_exist(me->device)
					&& strncmp(me->device, "/dev/hd", 7)
					&& strncmp(me->device, "/dev/sd", 7)) {
			sprintf(tmp, "Not formatting %s yet - doesn't exist - probably an LVM", me->device);
			log_it(tmp);
			continue;
		} else {
			if (interactively) {
				// ask user if we should format the current device
				sprintf(tmp, "Shall I format %s (%s) ?", me->device, me->mountpoint);
				do_it = ask_me_yes_or_no(tmp);
			} else {
				do_it = TRUE;
			}

			if (do_it)
				retval += format_device(me->device, me->format);
		}

		// update progress bar
		g_current_progress += progress_step;
	}


	// update progress bar to 100% to compensate for
	// rounding errors of the progress_step calculation
	if (lino >= mountlist->entries)
		g_current_progress = g_maximum_progress;

	close_progress_form();

	if (retval) {
		mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
		log_to_screen("Errors occurred during the formatting of your hard drives.");
	} else {
		mvaddstr_and_log_it(g_currentY++, 74, "Done.");
	}

	sprintf(tmp, "format_everything () - %s", (retval) ? "failed!" : "finished successfully");
	log_it(tmp);

	if (g_partition_table_locked_up > 0)
	  {
	    if (retval > 0 && !interactively)
              {
//123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 
                log_to_screen(
  "Partition table locked up %d times. At least one 'mkfs' (format) command", g_partition_table_locked_up);
                log_to_screen(
  "failed. I think these two events are related. Sometimes, fdisk's ioctl() call");
                log_to_screen(
  "to refresh its copy of the partition table causes the kernel to lock the ");
                log_to_screen(
  "partition table. I believe this has just happened.");
                if (ask_me_yes_or_no("Please choose 'yes' to reboot and try again; or 'no' to ignore this warning and continue."))
                  {
		    system("sync");
		    system("sync");
		    system("sync");
		    system("reboot"); 
		  }
	      }
	    else
	      {
	        log_to_screen(
"Partition table locked up %d time%c. However, disk formatting succeeded.", g_partition_table_locked_up, (g_partition_table_locked_up==1)?'.':'s');
	      }
	  }
        newtSuspend();
	system("clear");
	newtResume();
	paranoid_free(tmp);
	return (retval);
}


/**
 * Create small dummy partitions to fill in the gaps in partition numbering for @p drivename.
 * Each partition created is 32k in size.
 * @param drivename The drive to create the dummy partitions on.
 * @param devno_we_must_allow_for The lowest-numbered real partition; create
 * dummies up to (this - 1).
 * @return The number of errors encountered (0 for success).
 */
int make_dummy_partitions(FILE*pout_to_fdisk, char *drivename, int devno_we_must_allow_for)
{
	/** int **************************************************************/
	int current_devno;
	int previous_devno;
	int retval = 0;
	int res;

	/** buffers **********************************************************/
	char *tmp;

	/** end **************************************************************/

	malloc_string(tmp);
	assert_string_is_neither_NULL_nor_zerolength(drivename);

	if (devno_we_must_allow_for >= 5) {
		sprintf(tmp, "Making dummy primary %s%d", drivename, 1);
		log_it(tmp);
		g_maximum_progress++;
		res = partition_device(pout_to_fdisk,drivename, 1, 0, "ext2", 32000);
		retval += res;
		previous_devno = 1;
		current_devno = 5;
	} else {
		previous_devno = 0;
		current_devno = 1;
	}
	for (; current_devno < devno_we_must_allow_for; current_devno++) {
		sprintf(tmp, "Creating dummy partition %s%d", drivename, current_devno);
		log_it(tmp);
		g_maximum_progress++;
		res = partition_device(pout_to_fdisk,drivename, current_devno, previous_devno, OSSWAP("ext2", "ufs"), 32000);
		retval += res;
		previous_devno = current_devno;
	}
	paranoid_free(tmp);
	return (previous_devno);
}


/**
 * Decide whether @p mountlist contains any RAID devices.
 * @param mountlist The mountlist to examine.
 * @return TRUE if it does, FALSE if it doesn't.
 */
bool mountlist_contains_raid_devices(struct mountlist_itself * mountlist)
{
	/** int *************************************************************/
	int i;
	int matching = 0;

	/** end **************************************************************/

	assert(mountlist != NULL);

	for (i = 0; i < mountlist->entries; i++) {
		if (strstr(mountlist->el[i].device, RAID_DEVICE_STUB)) {
			matching++;
		}
	}
	if (matching) {
		return (TRUE);
	} else {
		return (FALSE);
	}
}

/* The following 2 functions are stolen from /usr/src/sbin/disklabel/disklabel.c */
#ifdef __FreeBSD__
static void display_disklabel(FILE * f, const struct disklabel *lp)
{
	int i, j;
	const struct partition *pp;

	fprintf(f, "# %s\n", "Generated by Mondo Rescue");
	if (lp->d_type < DKMAXTYPES)
		fprintf(f, "type: %s\n", dktypenames[lp->d_type]);
	else
		fprintf(f, "type: %u\n", lp->d_type);
	fprintf(f, "disk: %.*s\n", (int) sizeof(lp->d_typename), lp->d_typename);
	fprintf(f, "label: %.*s\n", (int) sizeof(lp->d_packname), lp->d_packname);
	fprintf(f, "flags:");
	if (lp->d_flags & D_REMOVABLE)
		fprintf(f, " removeable");
	if (lp->d_flags & D_ECC)
		fprintf(f, " ecc");
	if (lp->d_flags & D_BADSECT)
		fprintf(f, " badsect");
	fprintf(f, "\n");
	fprintf(f, "bytes/sector: %lu\n", (u_long) lp->d_secsize);
	fprintf(f, "sectors/track: %lu\n", (u_long) lp->d_nsectors);
	fprintf(f, "tracks/cylinder: %lu\n", (u_long) lp->d_ntracks);
	fprintf(f, "sectors/cylinder: %lu\n", (u_long) lp->d_secpercyl);
	fprintf(f, "cylinders: %lu\n", (u_long) lp->d_ncylinders);
	fprintf(f, "sectors/unit: %lu\n", (u_long) lp->d_secperunit);
	fprintf(f, "rpm: %u\n", lp->d_rpm);
	fprintf(f, "interleave: %u\n", lp->d_interleave);
	fprintf(f, "trackskew: %u\n", lp->d_trackskew);
	fprintf(f, "cylinderskew: %u\n", lp->d_cylskew);
	fprintf(f, "headswitch: %lu\t\t# milliseconds\n", (u_long) lp->d_headswitch);
	fprintf(f, "track-to-track seek: %ld\t# milliseconds\n", (u_long) lp->d_trkseek);
	fprintf(f, "drivedata: ");
	for (i = NDDATA - 1; i >= 0; i--)
		if (lp->d_drivedata[i])
			break;
	if (i < 0)
		i = 0;
	for (j = 0; j <= i; j++)
		fprintf(f, "%lu ", (u_long) lp->d_drivedata[j]);
	fprintf(f, "\n\n%u partitions:\n", lp->d_npartitions);
	fprintf(f, "#        size   offset    fstype   [fsize bsize bps/cpg]\n");
	pp = lp->d_partitions;
	for (i = 0; i < lp->d_npartitions; i++, pp++) {
		if (pp->p_size) {
			fprintf(f, "  %c: %8lu %8lu  ", 'a' + i, (u_long) pp->p_size, (u_long) pp->p_offset);
			if (pp->p_fstype < FSMAXTYPES)
				fprintf(f, "%8.8s", fstypenames[pp->p_fstype]);
			else
				fprintf(f, "%8d", pp->p_fstype);
			switch (pp->p_fstype) {

			case FS_UNUSED:	/* XXX */
				fprintf(f, "    %5lu %5lu %5.5s ", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag), "");
				break;

			case FS_BSDFFS:
				fprintf(f, "    %5lu %5lu %5u ", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag),
					pp->p_cpg);
				break;

			case FS_BSDLFS:
				fprintf(f, "    %5lu %5lu %5d", (u_long) pp->p_fsize, (u_long) (pp->p_fsize * pp->p_frag),
					pp->p_cpg);
				break;

			default:
				fprintf(f, "%20.20s", "");
				break;
			}
			fprintf(f, "\t# (Cyl. %4lu", (u_long) (pp->p_offset / lp->d_secpercyl));
			if (pp->p_offset % lp->d_secpercyl)
				putc('*', f);
			else
				putc(' ', f);
			fprintf(f, "- %lu", (u_long) ((pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl - 1));
			if (pp->p_size % lp->d_secpercyl)
				putc('*', f);
			fprintf(f, ")\n");
		}
	}
	fflush(f);
}

static struct disklabel *get_virgin_disklabel(char *dkname)
{
	static struct disklabel loclab;
	struct partition *dp;
	char lnamebuf[BBSIZE];
	int f;
	u_int secsize, u;
	off_t mediasize;

	(void) snprintf(lnamebuf, BBSIZE, "%s", dkname);
	if ((f = open(lnamebuf, O_RDONLY)) == -1) {
		warn("cannot open %s", lnamebuf);
		return (NULL);
	}

	/* New world order */
	if ((ioctl(f, DIOCGMEDIASIZE, &mediasize) != 0)
	    || (ioctl(f, DIOCGSECTORSIZE, &secsize) != 0)) {
		close(f);
		return (NULL);
	}
	memset(&loclab, 0, sizeof loclab);
	loclab.d_magic = DISKMAGIC;
	loclab.d_magic2 = DISKMAGIC;
	loclab.d_secsize = secsize;
	loclab.d_secperunit = mediasize / secsize;

	/*
	 * Nobody in these enligthened days uses the CHS geometry for
	 * anything, but nontheless try to get it right.  If we fail
	 * to get any good ideas from the device, construct something
	 * which is IBM-PC friendly.
	 */
	if (ioctl(f, DIOCGFWSECTORS, &u) == 0)
		loclab.d_nsectors = u;
	else
		loclab.d_nsectors = 63;
	if (ioctl(f, DIOCGFWHEADS, &u) == 0)
		loclab.d_ntracks = u;
	else if (loclab.d_secperunit <= 63 * 1 * 1024)
		loclab.d_ntracks = 1;
	else if (loclab.d_secperunit <= 63 * 16 * 1024)
		loclab.d_ntracks = 16;
	else
		loclab.d_ntracks = 255;
	loclab.d_secpercyl = loclab.d_ntracks * loclab.d_nsectors;
	loclab.d_ncylinders = loclab.d_secperunit / loclab.d_secpercyl;
	loclab.d_npartitions = MAXPARTITIONS;

	/* Various (unneeded) compat stuff */
	loclab.d_rpm = 3600;
	loclab.d_bbsize = BBSIZE;
	loclab.d_interleave = 1;;
	strncpy(loclab.d_typename, "amnesiac", sizeof(loclab.d_typename));

	dp = &loclab.d_partitions[RAW_PART];
	dp->p_size = loclab.d_secperunit;
	loclab.d_checksum = dkcksum(&loclab);
	close(f);
	return (&loclab);
}
/* End stolen from /usr/src/sbin/disklabel/disklabel.c. */

char *canonical_name(char *drivename)
{
	if (drivename) {
		if (strncmp(drivename, "/dev/", 5) == 0) {
			return drivename + 5;
		}
	}
	return drivename;
}

/**
 * (BSD only) Create a disklabel on @p drivename according to @p mountlist.
 * @param mountlist The mountlist to get the subpartition information from.
 * @param drivename The drive or slice to create a disklabel on.
 * @param ret If non-NULL, store the created disklabel here.
 * @return The number of errors encountered (0 for success).
 */
int label_drive_or_slice(struct mountlist_itself *mountlist, char *drivename, struct disklabel *ret)
{
	char subdev_str[MAX_STR_LEN];
	char command[MAX_STR_LEN];
	struct disklabel *lp;
	int i, lo = 0;
	int retval = 0;
	char c;
	FILE *ftmp;

	lp = get_virgin_disklabel(drivename);
	for (c = 'a'; c <= 'z'; ++c) {
		int idx;
		sprintf(subdev_str, "%s%c", drivename, c);
		if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) {
			lp->d_partitions[c - 'a'].p_size = 0;
			lp->d_partitions[c - 'a'].p_fstype = FS_UNUSED;
		} else {
			lo = c - 'a';
			lp->d_partitions[c - 'a'].p_size = mountlist->el[idx].size * 2;
			lp->d_partitions[c - 'a'].p_fsize = 0;
			lp->d_partitions[c - 'a'].p_frag = 0;
			lp->d_partitions[c - 'a'].p_cpg = 0;
			if (!strcmp(mountlist->el[idx].format, "ufs")
			    || !strcmp(mountlist->el[idx].format, "ffs")
			    || !strcmp(mountlist->el[idx].format, "4.2BSD")) {
				lp->d_partitions[c - 'a'].p_fstype = FS_BSDFFS;
				lp->d_partitions[c - 'a'].p_fsize = 2048;
				lp->d_partitions[c - 'a'].p_frag = 8;
				lp->d_partitions[c - 'a'].p_cpg = 64;
			} else if (!strcasecmp(mountlist->el[idx].format, "raid")
				   || !strcasecmp(mountlist->el[idx].format, "vinum")) {
				lp->d_partitions[c - 'a'].p_fstype = FS_VINUM;
			} else if (!strcmp(mountlist->el[idx].format, "swap")) {
				lp->d_partitions[c - 'a'].p_fstype = FS_SWAP;
			} else
				lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
		}
	}

	// fix up the offsets
	lp->d_partitions[0].p_offset = 0;
	lp->d_partitions[RAW_PART].p_offset = 0;
	lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;

	for (i = 1; i < lp->d_npartitions; ++i) {
		int lastone;
		if ((i == RAW_PART) || (lp->d_partitions[i].p_size == 0))
			continue;
		for (lastone = i - 1; lastone >= 0; lastone--) {
			if ((lp->d_partitions[lastone].p_size)
			    && (lastone != RAW_PART))
				break;
		}
		lp->d_partitions[i].p_offset = lp->d_partitions[lastone].p_offset + lp->d_partitions[lastone].p_size;
	}
	if (lp->d_partitions[lo].p_offset + lp->d_partitions[lo].p_size > lp->d_secperunit) {
		lp->d_partitions[lo].p_size = lp->d_secperunit - lp->d_partitions[lo].p_offset;
	}

	ftmp = fopen("/tmp/disklabel", "w");
	display_disklabel(ftmp, lp);
	fclose(ftmp);
	sprintf(command, "disklabel -wr %s auto", canonical_name(drivename));
	retval += run_program_and_log_output(command, TRUE);
	sprintf(command, "disklabel -R %s /tmp/disklabel", canonical_name(drivename));
	retval += run_program_and_log_output(command, TRUE);
	if (ret)
		*ret = *lp;
	return retval;
}
#endif


/**
 * Partition @p drivename based on @p mountlist.
 * @param mountlist The mountlist to use to guide the partitioning.
 * @param drivename The drive to partition.
 * @return 0 for success, nonzero for failure.
 */
int partition_drive(struct mountlist_itself *mountlist, char *drivename)
{
	/** int *************************************************************/
	int current_devno;
	int previous_devno = 0;
	int lino;
	int retval = 0;
	int i;
	FILE*pout_to_fdisk=NULL;
	
#ifdef __FreeBSD__
	bool fbsd_part = FALSE;
	char subdev_str[MAX_STR_LEN];
#endif

	/** long long *******************************************************/
	long long partsize;

	/** buffers *********************************************************/
	char *device_str;
	char *format;
	char *tmp;

	/** end *************************************************************/

	assert(mountlist != NULL);
	assert_string_is_neither_NULL_nor_zerolength(drivename);

	malloc_string(device_str);
	malloc_string(format);
	malloc_string(tmp);
	
	sprintf(tmp, "Partitioning drive %s", drivename);
	log_it(tmp);

#if __FreeBSD__	
        log_it("(Not opening fdisk now; that's the Linux guy's job)");
	pout_to_fdisk = NULL;
#else
	make_hole_for_file(FDISK_LOG);
#ifdef __IA64__
	sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
#else
	sprintf(tmp, "fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
#endif
	pout_to_fdisk = popen(tmp, "w");
	if (!pout_to_fdisk) { 
		log_to_screen("Cannot call fdisk to configure %s", drivename); 
		paranoid_free(device_str);
		paranoid_free(format);
		paranoid_free(tmp);
		return(1); 
	}
#endif
	for (current_devno = 1; current_devno < 99; current_devno++) {
		build_partition_name(device_str, drivename, current_devno);
		lino = find_device_in_mountlist(mountlist, device_str);

		if (lino < 0) {
			// device not found in mountlist
#if __FreeBSD__
			// If this is the first partition (just as a sentinel value),
			// then see if the user has picked 'dangerously-dedicated' mode.
			// If so, then we just call label_drive_or_slice() and return.
			char c;
			if (current_devno == 1) {
				// try DangerouslyDedicated mode
				for (c = 'a'; c <= 'z'; c++) {
					sprintf(subdev_str, "%s%c", drivename, c);
					if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
						fbsd_part = TRUE;
					}
				}
				if (fbsd_part) {
					int r = label_drive_or_slice(mountlist,
								     drivename,
								     0);
					char command[MAX_STR_LEN];
					sprintf(command, "disklabel -B %s", basename(drivename));
					if (system(command)) {
						log_to_screen("Warning! Unable to make the drive bootable.");
					}
					paranoid_free(device_str);
					paranoid_free(format);
					paranoid_free(tmp);
					return r;
				}
			}
			for (c = 'a'; c <= 'z'; c++) {
				sprintf(subdev_str, "%s%c", device_str, c);
				if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
					fbsd_part = TRUE;
				}
			}
			// Now we check the subpartitions of the current partition.
			if (fbsd_part) {
				int i, line;

				strcpy(format, "ufs");
				partsize = 0;
				for (i = 'a'; i < 'z'; ++i) {
					sprintf(subdev_str, "%s%c", device_str, i);
					line = find_device_in_mountlist(mountlist, subdev_str);
					if (line > 0) {
						// We found one! Add its size to the total size.
						partsize += mountlist->el[line].size;
					}
				}
			} else {
				continue;
			}
#else
			continue;
#endif
		}

		/* OK, we've found partition /dev/hdxN in mountlist; let's prep it */
		/* For FreeBSD, that is      /dev/adXsY */

		log_it("Found partition %s in mountlist", device_str);
		if (!previous_devno) {

			log_it("Wiping %s's partition table", drivename);
#if __FreeBSD__
			// FreeBSD doesn't let you write to blk devices in <512byte chunks.
//			sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
//			if (run_program_and_log_output(tmp, TRUE)) {
			file = open(drivename, O_WRONLY);
			if (!file) {
				sprintf(tmp, "Warning - unable to open %s for wiping it's partition table", drivename);
				log_to_screen(tmp);
			}

			for (i=0; i<512; i++) {
				if ( !write(file, "\0", 1) ) {
					sprintf(tmp, "Warning - unable to write to %s", drivename);
					log_to_screen(tmp);
				}
			}
			system("sync");
#else
			iamhere("New, kernel-friendly partition remover");
			for(i=20;i>0;i--)
			  {
			    fprintf(pout_to_fdisk, "d\n%d\n", i);
			    fflush(pout_to_fdisk);
			  }
//			sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
//			run_program_and_log_output(tmp, 1);
#endif	
			if (current_devno > 1) {
				previous_devno = make_dummy_partitions(pout_to_fdisk,drivename, current_devno);
			}
		}
#ifdef __FreeBSD__
		if (!fbsd_part) {
#endif

		strcpy(format, mountlist->el[lino].format);
		partsize = mountlist->el[lino].size;

#ifdef __FreeBSD__
		}
#endif

		if (current_devno == 5 && previous_devno == 4) {
			log_to_screen("You must leave at least one partition spare as the Extended partition.");
			paranoid_free(device_str);
			paranoid_free(format);
			paranoid_free(tmp);
			return (1);
		}

		retval += partition_device(pout_to_fdisk, drivename, current_devno, previous_devno, format, partsize);

#ifdef __FreeBSD__
		if ((current_devno <= 4) && fbsd_part) {
			sprintf(tmp, "disklabel -B %s", basename(device_str));
			retval += label_drive_or_slice(mountlist, device_str, 0);
			if (system(tmp)) {
				log_to_screen("Warning! Unable to make the slice bootable.");
			}
		}
#endif

		previous_devno = current_devno;
	}

	if (pout_to_fdisk)
	{
// mark relevant partition as bootable
		sprintf(tmp, "a\n%s\n", call_program_and_get_last_line_of_output("make-me-bootable /tmp/mountlist.txt dummy"));
		fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
// close fdisk
		fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
		system("sync");
		paranoid_pclose(pout_to_fdisk); 
		log_msg(0, "------------------- fdisk.log looks like this ------------------");
		sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
		system(tmp);
		log_msg(0, "------------------- end of fdisk.log... word! ------------------");
		sprintf(tmp, "tail -n6 %s | fgrep \"16: \"", FDISK_LOG);
		if (!run_program_and_log_output(tmp, 5))
		  {
		    g_partition_table_locked_up++;
		    log_to_screen("A flaw in the Linux kernel has locked the partition table.");
		  }
	}
	paranoid_free(device_str);
	paranoid_free(format);
	paranoid_free(tmp);
	return (retval);
}

/**
 * Create partition number @p partno on @p drive with @p fdisk.
 * @param drive The drive to create the partition on.
//  * @param partno The partition number of the new partition (1-4 are primary, >=5 is logical).
 * @param prev_partno The partition number of the most recently prepped partition.
 * @param format The filesystem type of this partition (used to set the type).
 * @param partsize The size of the partition in @e bytes.
 * @return 0 for success, nonzero for failure.
 */
int partition_device(FILE*pout_to_fdisk, const char *drive, int partno, int prev_partno, const char *format, long long partsize)
{
	/** int **************************************************************/
	int retval = 0;
	int res = 0;

	/** buffers **********************************************************/
	char *program;
	char *partition_name;
	char *tmp;
	char *logfile;
	char *output;

	/** pointers **********************************************************/
	char *p;
	char *part_table_fmt;
	FILE *fout;

	/** end ***************************************************************/

	malloc_string(program);
	malloc_string(partition_name);
	malloc_string(tmp);
	malloc_string(logfile);
	malloc_string(output);
	
	assert_string_is_neither_NULL_nor_zerolength(drive);
	assert(format != NULL);

	log_it("partition_device('%s', %d, %d, '%s', %lld) --- starting", drive, partno, prev_partno, format, partsize);

	if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
		sprintf(tmp, "Not partitioning %s - it is a virtual drive", drive);
		log_it(tmp);
		paranoid_free(program);
		paranoid_free(partition_name);
		paranoid_free(tmp);
		paranoid_free(logfile);
		paranoid_free(output);
		return (0);
	}
	build_partition_name(partition_name, drive, partno);
	if (partsize <= 0) {
		sprintf(tmp, "Partitioning device %s (max size)", partition_name);
	} else {
		sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name, (long long) partsize / 1024);
	}
	update_progress_form(tmp);
	log_it(tmp);

	if (is_this_device_mounted(partition_name)) {
		sprintf(tmp, "%s is mounted, and should not be partitioned", partition_name);
		log_to_screen(tmp);
		paranoid_free(program);
		paranoid_free(partition_name);
		paranoid_free(tmp);
		paranoid_free(logfile);
		paranoid_free(output);
		return (1);
/*
	} else if (does_partition_exist(drive, partno)) {
		sprintf(tmp, "%s already has a partition", partition_name);
		log_to_screen(tmp);
		return (1);
*/
	}


	/*  sprintf(tmp,"Partitioning %s  ",partition_name); */
	/*  mvaddstr_and_log_it(g_currentY+1,30,tmp); */
	p = (char *) strrchr(partition_name, '/');
	sprintf(logfile, "/tmp/fdisk.log.%s", ++p);
	sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);

	output[0] = '\0';
	/* make it a primary/extended/logical */
	if (partno <= 4) {
		sprintf(output + strlen(output), "n\np\n%d\n", partno);
	} else {
		if (partno == 5) {
			part_table_fmt = which_partition_format(drive);
			/* GPT allows more than 4 primary partitions */
			if ((prev_partno >= 4) && (strcmp(part_table_fmt,"MBR") == 0)) {
				log_to_screen("You need to leave at least one partition free, for 'extended/logical'");
				paranoid_free(program);
				paranoid_free(partition_name);
				paranoid_free(tmp);
				paranoid_free(logfile);
				paranoid_free(output);
				return (1);
			} else {
				sprintf(output + strlen(output), "n\ne\n%d\n\n\n", prev_partno + 1);
			}
		}
		strcat(output + strlen(output), "n\nl\n");
	}
	strcat(output + strlen(output), "\n");	/*start block (ENTER for next free blk */
	if (partsize > 0) {
                if (!strcmp(format, "7")) { log_msg(1, "Adding 512K, just in case"); partsize+=512; }
		sprintf(output + strlen(output), "+%lldK", (long long) (partsize));
	}
	strcat(output + strlen(output), "\n");
#if 0
/*
#endif
	sprintf(tmp,"PARTSIZE = +%ld",(long)partsize);
	log_it(tmp);
	log_it("---fdisk command---");
	log_it(output);
	log_it("---end of fdisk---");
#if 0
*/
#endif


	if (pout_to_fdisk)
	{
		log_msg(1, "Doing the new all-in-one fdisk thing");
		log_msg(1, "output = '%s'", output);
		fput_string_one_char_at_a_time(pout_to_fdisk, output);
		fput_string_one_char_at_a_time(pout_to_fdisk, "\n\np\n");
		strcpy(tmp, last_line_of_file(FDISK_LOG));
		if (strstr(tmp, " (m "))
		{
			log_msg(1, "Successfully created %s%d", drive, partno);
		}
		else
		{
			log_msg(1, "last line = %s", tmp);
			log_msg(1, "Failed to create %s%d; sending 'Enter'...", drive, partno);
		}
		if (!retval)
		{
			log_msg(1, "Trying to set %s%d's partition type now", drive, partno);
			retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
			if (retval)
			{
				log_msg(1, "Failed. Trying again...");
		    		retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
			}
		  }
		if (retval) { log_msg(1, "...but failed to set type"); }
	}
	else
	{
		strcat(output, "w\n\n");
        	if (g_fprep) { fprintf(g_fprep, "echo \"%s\" | %s\n", output, program); }
		/* write to disk; close fdisk's stream */
		if (!(fout = popen(program, "w"))) {
			log_OS_error("can't popen-out to program");
		} else {
			fputs(output, fout);
			paranoid_pclose(fout);
		}
		if (!does_partition_exist(drive, partno) && partsize > 0) {
			log_it("Vaccum-packing");
			g_current_progress--;
			res = partition_device(pout_to_fdisk, drive, partno, prev_partno, format, -1);
			if (res) {
				sprintf(tmp, "Failed to vacuum-pack %s", partition_name);
				log_it(tmp);
				retval++;
			} else {
				retval = 0;
			}
		}
		if (does_partition_exist(drive, partno)) {
			retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
			if (retval) {
				sprintf(tmp, "Partitioned %s but failed to set its type", partition_name);
				log_it(tmp);
			} else {
				if (partsize > 0) {
					sprintf(tmp, "Partition %s created+configured OK", partition_name);
					log_to_screen(tmp);
				} else {
					log_it("Returning from a successful vacuum-pack");
				}
			}
			} else {
			sprintf(tmp, "Failed to partition %s", partition_name);
			if (partsize > 0) {
				log_to_screen(tmp);
			} else {
				log_it(tmp);
			}
			retval++;
		}
	}
	g_current_progress++;
	log_it("partition_device() --- leaving");
	paranoid_free(program);
	paranoid_free(partition_name);
	paranoid_free(tmp);
	paranoid_free(logfile);
	paranoid_free(output);
	return (retval);
}



/**
 * Create all partitions listed in @p mountlist.
 * @param mountlist The mountlist to use to guide the partitioning.
 * @return The number of errors encountered (0 for success).
 * @note This sets the partition types but doesn't actually do the formatting.
 * Use format_everything() for that.
 */
int partition_everything(struct mountlist_itself *mountlist)
{
	/** int ************************************************************/
	int lino;
	int retval = 0;
	int i;
	int res;

	/** buffer *********************************************************/
	struct list_of_disks *drivelist;
	/*  struct mountlist_itself new_mtlist, *mountlist; */

	/** end ************************************************************/

	drivelist = malloc(sizeof(struct list_of_disks));
	assert(mountlist != NULL);

	log_it("partition_everything() --- starting");
	mvaddstr_and_log_it(g_currentY, 0, "Partitioning hard drives      ");
	/*  mountlist=orig_mtlist; */
	if (mountlist_contains_raid_devices(mountlist)) {
		/*      mountlist=&new_mtlist; */
		/*      extrapolate_mountlist_to_include_raid_partitions(mountlist,orig_mtlist); */
		log_msg(0,"Mountlist, including the partitions incorporated in RAID devices:-");
		for (i = 0; i < mountlist->entries; i++) {
			log_it(mountlist->el[i].device);
		}
		log_msg(0, "End of mountlist.");
	}
	log_msg(0, "Stopping all LVMs, just in case");
        if (!g_text_mode) { newtSuspend(); }
	do_my_funky_lvm_stuff(TRUE, FALSE); // just remove old partitions
        if (!g_text_mode) { newtResume(); }
	log_msg(0, "Stopping all software RAID devices, just in case");
	stop_all_raid_devices(mountlist);
	log_msg(0, "Done.");
	
/*	
	if (does_file_exist("/tmp/i-want-my-lvm"))
	  {
	    wipe_MBRs_and_reboot_if_necessary(mountlist); // i.e. if it wasn't done recently
	  }
*/

	open_progress_form("Partitioning devices", "I am now going to partition all your drives.",
			   "This should not take more than five minutes.", "", mountlist->entries);

	make_list_of_drives_in_mountlist(mountlist, drivelist);

	/* partition each drive */
	for (lino = 0; lino < drivelist->entries; lino++) {
		res = partition_drive(mountlist, drivelist->el[lino].device);
		retval += res;
	}
	close_progress_form();
	if (retval) {
		mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
		log_to_screen("Errors occurred during the partitioning of your hard drives.");
	} else {
		mvaddstr_and_log_it(g_currentY++, 74, "Done.");
		paranoid_system("rm -f /tmp/fdisk*.log 2> /dev/null");
	}
	newtSuspend();
	system("clear");
	newtResume();
	paranoid_free(drivelist);
	return (retval);
}






/**
 * Set the type of partition number @p partno on @p drive to @p format.
 * @param drive The drive to change the type of a partition on.
 * @param partno The partition number on @p drive to change the type of.
 * @param format The filesystem type this partition will eventually contain.
 * @param partsize The size of this partition, in @e bytes (used for vfat
 * type calculations).
 * @return 0 for success, nonzero for failure.
 */
int set_partition_type(FILE *pout_to_fdisk, const char *drive, int partno, const char *format, long long partsize)
{
	/** buffers *********************************************************/
  char *partition;
  char *command;
  char *output;
  char *tmp;
  char *partcode;
  char *logfile;

	/** pointers *********************************************************/
	char *p;
	FILE *fout;

	/** int **************************************************************/
	int res = 0;

	/** end **************************************************************/

	assert_string_is_neither_NULL_nor_zerolength(drive);
	assert(format != NULL);

  malloc_string(partition);
  malloc_string(command);
  malloc_string(output);
  malloc_string(tmp);
  malloc_string(partcode);
  malloc_string(logfile);

	build_partition_name(partition, drive, partno);
	p = (char *) strrchr(partition, '/');
	sprintf(logfile, "/tmp/fdisk-set-type.%s.log", ++p);
	if (strcmp(format, "swap") == 0) {
		strcpy(partcode, "82");
	} else if (strcmp(format, "vfat") == 0) {
		if (partsize / 1024 > 8192) {
			strcpy(partcode, "c");
		} else {
			strcpy(partcode, "b");
		}
	} else if (strcmp(format, "ext2") == 0 || strcmp(format, "reiserfs") == 0 || strcmp(format, "ext3") == 0
		   || strcmp(format, "xfs") == 0 || strcmp(format, "jfs") == 0) {
		strcpy(partcode, "83");
	} else if (strcmp(format, "minix") == 0) {
		strcpy(partcode, "81");
	} else if (strcmp(format, "raid") == 0) {
		strcpy(partcode, "fd");
	} else if ((strcmp(format, "ufs") == 0)
		   || (strcmp(format, "ffs") == 0)) {	/* raid autodetect */
		strcpy(partcode, "a5");
	} else if (strcmp(format, "lvm") == 0) {
		strcpy(partcode, "8e");
	} else if (format[0] == '\0') {	/* LVM physical partition */
		partcode[0] = '\0';
	} else if (strlen(format) >= 1 && strlen(format) <= 2) {
		strcpy(partcode, format);
	} else {
		/* probably an image */
		sprintf(tmp, "Unknown format ('%s') - using supplied string anyway", format);
		mvaddstr_and_log_it(g_currentY++, 0, tmp);
#ifdef __FreeBSD__
		strcpy(partcode, format); // was a5
#else
		strcpy(partcode, format); // was 83
#endif
	}
	sprintf(tmp, "Setting %s's type to %s (%s)", partition, format, partcode);
	log_msg(1, tmp);
	if (partcode[0] != '\0' && strcmp(partcode, "83")) {	/* no need to set type if 83: 83 is default */
		
		if (pout_to_fdisk)
		{
			res = 0;
			fput_string_one_char_at_a_time(pout_to_fdisk, "t\n");
			if (partno > 1 || strstr(last_line_of_file(FDISK_LOG), " (1-4)"))
			{
				log_msg(5, "Specifying partno (%d) - yay", partno);
				sprintf(tmp, "%d\n", partno);
				fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
				log_msg(5, "A - last line = '%s'", last_line_of_file(FDISK_LOG));
			}
			
			sprintf(tmp, "%s\n", partcode);
			fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
			log_msg(5, "B - last line = '%s'", last_line_of_file(FDISK_LOG));
			fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
			log_msg(5, "C - last line = '%s'", last_line_of_file(FDISK_LOG));
			
			strcpy(tmp, last_line_of_file(FDISK_LOG));
			if (!strstr(tmp, " (m "))
			  { 
			    log_msg(1, "last line = '%s'; part type set failed", tmp);
			    res++; 
			    fput_string_one_char_at_a_time(pout_to_fdisk,"\n");
			  }
			fput_string_one_char_at_a_time(pout_to_fdisk,"p\n");
		}
		else
		{
			sprintf(output, "t\n%d\n%s\n", partno, partcode);
			strcat(output, "w\n");
			sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
			log_msg(5, "output = '%s'", output);
			log_msg(5, "partno=%d; partcode=%s", partno, partcode);
			log_msg(5, "command = '%s'", command);
			fout = popen(command, "w");
			if (!fout) {
				log_OS_error(command);
				res = 1;
			} else {
				res = 0;
				fprintf(fout, output);
				paranoid_pclose(fout);
			}
		}
	if (res)
	  {
	    log_OS_error(command);
	  }	
	}

  paranoid_free(partition);
  paranoid_free(command);
  paranoid_free(output);
  paranoid_free(tmp);
  paranoid_free(partcode);
  paranoid_free(logfile);

  return (res);
}


int start_raid_device(char *raid_device)
{
	/** int *************************************************************/
	int res;
	int retval = 0;

	/** buffers *********************************************************/
	char *program;

	/** end *************************************************************/

	assert_string_is_neither_NULL_nor_zerolength(raid_device);
	malloc_string(program);
	
#ifdef __FreeBSD__
	if (is_this_device_mounted(raid_device)) {
		log_it("Can't start %s when it's mounted!", raid_device);
		return 1;
	}
	sprintf(program, "vinum start -f %s", raid_device);
#else
	sprintf(program, "raidstart %s", raid_device);
//      sprintf (program, "raidstart " RAID_DEVICE_STUB "*");
#endif
	log_msg(1, "program = %s", program);
	res = run_program_and_log_output(program, 1);
	if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
	if (res) { log_msg(1, "Warning - failed to start RAID device %s", raid_device); }
	retval += res;
	sleep(1);
	return (retval);
}



/**
 * Stop @p raid_device using @p raidstop.
 * @param raid_device The software RAID device to stop.
 * @return 0 for success, nonzero for failure.
 */
int stop_raid_device(char *raid_device)
{
	/** int *************************************************************/
	int res;
	int retval = 0;

	/** buffers *********************************************************/
	char *program;

	/** end *************************************************************/

	assert_string_is_neither_NULL_nor_zerolength(raid_device);
	malloc_string(program);
	
#ifdef __FreeBSD__
	if (is_this_device_mounted(raid_device)) {
		log_it("Can't stop %s when it's mounted!", raid_device);
		return 1;
	}
	sprintf(program, "vinum stop -f %s", raid_device);
#else
	sprintf(program, "raidstop %s", raid_device);
//      sprintf (program, "raidstop " RAID_DEVICE_STUB "*");
#endif
	log_msg(1, "program = %s", program);
	res = run_program_and_log_output(program, 1);
	if (g_fprep) { fprintf(g_fprep, "%s\n", program); }
	if (res) { log_msg(1, "Warning - failed to stop RAID device %s", raid_device); }
	retval += res;
	return (retval);
}


int start_all_raid_devices(struct mountlist_itself *mountlist)
{
	int i;
	int retval=0;
	int res;
	
	for(i=0; i<mountlist->entries; i++)
	  {
	    if (!strncmp(mountlist->el[i].device, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB)))
	      {
	        log_msg(1, "Starting %s", mountlist->el[i].device);
		res = start_raid_device(mountlist->el[i].device);
		retval += res;
	      }
	  }
	if (retval) { log_msg(1, "Started all s/w raid devices OK"); }
	else { log_msg(1, "Failed to start some/all s/w raid devices"); }
	return(retval);
}

/**
 * Stop all software RAID devices listed in @p mountlist.
 * @param mountlist The mountlist to stop the RAID devices in.
 * @return The number of errors encountered (0 for success).
 * @bug @p mountlist is not used.
 */
int stop_all_raid_devices(struct mountlist_itself *mountlist)
{
	/** int *************************************************************/
	int retval = 0;
#ifndef __FreeBSD__
	int res;
#endif

	/** char ************************************************************/
	char *incoming;
#ifndef __FreeBSD__
	char *dev;
#endif
	/** pointers ********************************************************/
#ifndef __FreeBSD__
	char *p;
#endif
	FILE *fin;
	int i;

	/** end ****************************************************************/

	malloc_string(dev);
	malloc_string(incoming);
	assert(mountlist != NULL);

	for (i = 0; i < 3; i++) {
#ifdef __FreeBSD__
		fin = popen("vinum list | grep '^[PVS]' | sed 's/S/1/;s/P/2/;s/V/3/' | sort | cut -d' ' -f2", "r");
		if (!fin) {
			paranoid_free(dev);
			paranoid_free(incoming);
			return (1);
		}
		for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin); fgets(incoming, MAX_STR_LEN - 1, fin)) {
			retval += stop_raid_device(incoming);
		}
#else
		fin = fopen("/proc/mdstat", "r");
		if (!fin) {
			log_OS_error("/proc/mdstat");
			paranoid_free(dev);
			paranoid_free(incoming);
			return (1);
		}
		for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin); fgets(incoming, MAX_STR_LEN - 1, fin)) {
			for (p = incoming; *p != '\0' && (*p != 'm' || *(p + 1) != 'd' || !isdigit(*(p + 2))); p++);
			if (*p != '\0') {
				sprintf(dev, "/dev/%s", p);
				for (p = dev; *p > 32; p++);
				*p = '\0';
				res = stop_raid_device(dev);
			}
		}
#endif
	}
	paranoid_fclose(fin);
	if (retval) { log_msg(1, "Warning - unable to stop some RAID devices"); }
	paranoid_free(dev);
	paranoid_free(incoming);
	system("sync"); system("sync"); system("sync"); 
	sleep(1);
	return (retval);
}



/**
 * Decide which command we need to use to format a device of type @p format.
 * @param format The filesystem type we are about to format.
 * @param program Where to put the binary name for this format.
 * @return 0 for success, nonzero for failure.
 */
int which_format_command_do_i_need(char *format, char *program)
{
	/** int *************************************************************/
	int res = 0;

	/** buffers *********************************************************/
	char *tmp;

	/** end ***************************************************************/

	malloc_string(tmp);
	assert_string_is_neither_NULL_nor_zerolength(format);
	assert(program != NULL);

	if (strcmp(format, "swap") == 0) {
#ifdef __FreeBSD__
		strcpy(program, "true");
#else
		strcpy(program, "mkswap");
#endif
	} else if (strcmp(format, "vfat") == 0) {
		strcpy(program, "format-and-kludge-vfat");
#ifndef __FreeBSD__
	} else if (strcmp(format, "reiserfs") == 0) {
		strcpy(program, "mkreiserfs -ff");
	} else if (strcmp(format, "xfs") == 0) {
		strcpy(program, "mkfs.xfs -f -q");
	} else if (strcmp(format, "jfs") == 0) {
		strcpy(program, "mkfs.jfs");
	} else if (strcmp(format, "ext3") == 0) {
		strcpy(program, "mkfs -t ext2 -F -j -q");
	} else if (strcmp(format, "minix") == 0) {
		strcpy(program, "mkfs.minix");
#endif
	} else if (strcmp(format, "ext2") == 0) {
		strcpy(program, "mke2fs -F -q");
	} else {
#ifdef __FreeBSD__
		sprintf(program, "newfs_%s", format);
#else
		sprintf(program, "mkfs -t %s -c", format);	// -c checks for bad blocks
#endif
		sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format, program);
		log_it(tmp);
		res = 0;
	}
	paranoid_free(tmp);
	return (res);
}


/**
 * Calculate the probable size of @p drive_name by adding up sizes in
 * @p mountlist.
 * @param mountlist The mountlist to use to calculate the size.
 * @param drive_name The drive to calculate the original size of.
 * @return The size of @p drive_name in kilobytes.
 */
long calc_orig_size_of_drive_from_mountlist(struct mountlist_itself
					    *mountlist, char *drive_name)
{
	/** long ************************************************************/
	long original_size_of_drive;

	/** int *************************************************************/
	int partno;

	/** buffers *********************************************************/
	char *tmp;

	/** end *************************************************************/

	malloc_string(tmp);
	assert(mountlist != NULL);
	assert_string_is_neither_NULL_nor_zerolength(drive_name);

	for (original_size_of_drive = 0, partno = 0; partno < mountlist->entries; partno++) {
		if (strncmp(mountlist->el[partno].device, drive_name, strlen(drive_name)) == 0) {
			original_size_of_drive += mountlist->el[partno].size;
		} else {
			sprintf(tmp, "Skipping %s", mountlist->el[partno].device);
//                      log_to_screen(tmp);
		}
	}
	original_size_of_drive = original_size_of_drive / 1024;
	paranoid_free(tmp);
	return (original_size_of_drive);
}


/**
 * Resize a drive's entries in @p mountlist proportionately to fit its new size.
 * There are a few problems with this function:
 * - It won't work if there was any unallocated space on the user's hard drive
 *   when it was backed up.
 * - It won't work if the user's hard drive lies about its size (more common
 *   than you'd think).
 *
 * @param mountlist The mountlist to use for resizing @p drive_name.
 * @param drive_name The drive to resize.
 */
void resize_drive_proportionately_to_suit_new_drives(struct mountlist_itself
						     *mountlist, char *drive_name)
{
	/**buffers **********************************************************/
	char *tmp;

	/** int *************************************************************/
	int partno, lastpart;
		       /** remove driveno, noof_drives stan benoit apr 2002**/

	/** float ***********************************************************/
	float factor;
	float new_size;
//	float newcylinderno;

	/** long *************************************************************/
	long newsizL;
	long current_size_of_drive = 0;
	long original_size_of_drive = 0;
	long final_size;	/* all in Megabytes */
	struct mountlist_reference *drivemntlist;

	/** structures *******************************************************/

	/** end **************************************************************/

	malloc_string(tmp);
	assert(mountlist != NULL);
	assert_string_is_neither_NULL_nor_zerolength(drive_name);

	if (strlen(drive_name) >= strlen(RAID_DEVICE_STUB)) {
		if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB)) == 0) {
			paranoid_free(tmp);
			return;
		}
	}

	/*
	   sprintf (tmp, "cp -f %s %s.pre-resize", g_mountlist_fname, g_mountlist_fname);
	   run_program_and_log_output (tmp, FALSE);
	 */

	current_size_of_drive = get_phys_size_of_drive(drive_name);
	
	if (current_size_of_drive <= 0) {
		log_it("Not resizing to match %s - can't find drive", drive_name);
		paranoid_free(tmp);
		return;
	}
	sprintf(tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name, current_size_of_drive);
	log_to_screen(tmp);

	drivemntlist = malloc(sizeof (struct mountlist_reference));
	drivemntlist->el = malloc(sizeof(struct mountlist_line *) * MAX_TAPECATALOG_ENTRIES);

	if (!drivemntlist) {
		fatal_error("Cannot malloc temporary mountlist\n");
	}
	create_mountlist_for_drive(mountlist, drive_name, drivemntlist);

	for (partno = 0; partno < drivemntlist->entries; partno++) {
		original_size_of_drive += drivemntlist->el[partno]->size;
	}
	original_size_of_drive = original_size_of_drive / 1024;

	if (original_size_of_drive <= 0) {
		sprintf(tmp, "Cannot resize %s's entries. Drive not found.", drive_name);
		log_to_screen(tmp);
		paranoid_free(tmp);
		return;
	}
	factor = (float) (current_size_of_drive) / (float) (original_size_of_drive);
	sprintf(tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f", drive_name, original_size_of_drive, current_size_of_drive,
		factor);
	log_to_screen(tmp);

	lastpart = drivemntlist->entries-1;
	for (partno = 0; partno < drivemntlist->entries; partno++) {
		/* the 'atoi' thing is to make sure we don't try to resize _images_, whose formats will be numeric */
		if ( !atoi(drivemntlist->el[partno]->format) ) {
			new_size = (float) (drivemntlist->el[partno]->size) * factor;
		} else {
			new_size = drivemntlist->el[partno]->size;
		}
		
		if (!strcmp(drivemntlist->el[partno]->mountpoint, "image")) {
			log_msg(1, "Skipping %s (%s) because it's an image",
							drivemntlist->el[partno]->device,
							drivemntlist->el[partno]->mountpoint);
			newsizL = (long) new_size; // It looks wrong but it's not
		} else {
			newsizL = (long) new_size;
		}
		sprintf(tmp, "Changing %s from %lld KB to %ld KB", drivemntlist->el[partno]->device, drivemntlist->el[partno]->size,newsizL);
		log_to_screen(tmp);
		drivemntlist->el[partno]->size = newsizL;
	}
	final_size = get_phys_size_of_drive(drive_name);
	sprintf(tmp, "final_size = %ld MB", final_size);
	paranoid_free(tmp);
	log_to_screen(tmp);
}


/**
 * Resize all partitions in @p mountlist proportionately (each one
 * grows or shrinks by the same percentage) to fit them into the new
 * drives (presumably different from the old ones).
 * @param mountlist The mountlist to resize the drives in.
 */
void resize_mountlist_proportionately_to_suit_new_drives(struct mountlist_itself
							 *mountlist)
{
	/** buffers *********************************************************/
	struct list_of_disks *drivelist;

	/** int *************************************************************/
	int driveno;

	/** end *************************************************************/

	drivelist = malloc(sizeof(struct list_of_disks));
	assert(mountlist != NULL);

	if (g_mountlist_fname[0] == '\0') {
	    log_it ("resize_mountlist_prop...() - warning - mountlist fname is blank");
	    log_it ("That does NOT affect the functioning of this subroutine.");
	    log_it ("--- Hugo, 2002/11/20");
	}
	iamhere("Resizing mountlist");
	make_list_of_drives_in_mountlist(mountlist, drivelist);
	iamhere("Back from MLoDiM");
	for (driveno = 0; driveno < drivelist->entries; driveno++) {
		resize_drive_proportionately_to_suit_new_drives(mountlist, drivelist->el[driveno].device);
	}
	log_to_screen("Mountlist adjusted to suit current hard drive(s)");
	paranoid_free(drivelist);
}

/**
 * Create a mountlist_reference structure for @p drive_name in @p mountlist.
 * @param mountlist The complete mountlist to get the drive references from.
 * @param drive_name The drive to put in @p drivemntlist.
 * @param drivemntlist The mountlist_reference structure to put the drive's entries in.
 * @note @p drivemntlist and @p drivemntlist->el must be allocated by the caller.
 * @author Ralph Grewe
 */
void create_mountlist_for_drive(struct mountlist_itself *mountlist, char *drive_name, struct mountlist_reference *drivemntlist) {
	int partno;
	char *tmp_drive_name, *c;

	assert(mountlist != NULL);
	assert(drive_name != NULL);
	assert(drivemntlist != NULL);

	log_msg (1, "Creating list of partitions for drive %s",drive_name);

	tmp_drive_name = strdup (drive_name);
	if (!tmp_drive_name) fatal_error ("Out of memory");
	
	/* devfs devices? */
	c = strrchr (tmp_drive_name, '/');
	if (c && strncmp (c, "/disc", 5) == 0) {
	    /* yup its devfs, change the "disc" to "part" so the existing code works */
	    strcpy (c + 1, "part");
	}
	drivemntlist->entries=0;
	for (partno = 0; partno < mountlist->entries; partno++) {
		if (strncmp (mountlist->el[partno].device, tmp_drive_name, strlen(tmp_drive_name)) == 0) {
			drivemntlist->el[drivemntlist->entries] = &mountlist->el[partno];
			drivemntlist->entries++;
		}
	}
	if (tmp_drive_name)
	    free (tmp_drive_name);
}

/* @} - end of prepGroup */
