1 files changed, 132 insertions, 374 deletions

diff --git a/mdk-stage1/tools.c b/mdk-stage1/tools.c
index dbbd45772..2e27688ea 100644
--- a/mdk-stage1/tools.c
+++ b/mdk-stage1/tools.c
@@ -1,7 +1,7 @@
 /*
- * Guillaume Cottenceau (gc@mandrakesoft.com)
+ * Guillaume Cottenceau (gc)
  *
- * Copyright 2000 MandrakeSoft
+ * Copyright 2000 Mandriva
  *
  * This software may be freely redistributed under the terms of the GNU
  * public license.
@@ -26,15 +26,12 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <dirent.h>
 #include <sys/types.h>
-#include <bzlib.h>
 #include <sys/mount.h>
 #include <sys/poll.h>
 #include <errno.h>
-#include <sys/utsname.h>
 #include <sys/ioctl.h>
 #include <linux/fd.h>
 #include "stage1.h"
@@ -44,446 +41,233 @@
 #include "automatic.h"
 
 #include "tools.h"
+#include "utils.h"
+#include "params.h"
 #include "probing.h"
 #include "modules.h"
+#include "lomount.h"
 
-static struct param_elem params[50];
-static int param_number = 0;
-
-void process_cmdline(void)
+int image_has_stage2()
 {
-	char buf[512];
-	int fd, size, i;
-	
-	log_message("opening /proc/cmdline... ");
-	
-	if ((fd = open("/proc/cmdline", O_RDONLY)) == -1)
-		fatal_error("could not open /proc/cmdline");
-	
-	size = read(fd, buf, sizeof(buf));
-	buf[size-1] = '\0'; // -1 to eat the \n
-	close(fd);
-
-	log_message("\t%s", buf);
-
-	i = 0;
-	while (buf[i] != '\0') {
-		char *name, *value = NULL;
-		int j = i;
-		while (buf[i] != ' ' && buf[i] != '=' && buf[i] != '\0')
-			i++;
-		if (i == j) {
-			i++;
-			continue;
-		}
-		name = memdup(&buf[j], i-j + 1);
-		name[i-j] = '\0';
-
-		if (buf[i] == '=') {
-			int k = i+1;
-			i++;
-			while (buf[i] != ' ' && buf[i] != '\0')
-				i++;
-			value = memdup(&buf[k], i-k + 1);
-			value[i-k] = '\0';
-		}
-
-		params[param_number].name = name;
-		params[param_number].value = value;
-		param_number++;
-		if (!strcmp(name, "expert")) set_param(MODE_EXPERT);
-		if (!strcmp(name, "changedisk")) set_param(MODE_CHANGEDISK);
-		if (!strcmp(name, "updatemodules")) set_param(MODE_UPDATEMODULES);
-		if (!strcmp(name, "rescue")) set_param(MODE_RESCUE);
-		if (!strcmp(name, "noauto")) set_param(MODE_NOAUTO);
-		if (!strcmp(name, "netauto")) set_param(MODE_NETAUTO);
-		if (!strcmp(name, "recovery")) set_param(MODE_RECOVERY);
-		if (!strcmp(name, "special_stage2")) set_param(MODE_SPECIAL_STAGE2);
-		if (!strcmp(name, "debugstage1")) set_param(MODE_DEBUGSTAGE1);
-		if (!strcmp(name, "automatic")) {
-			set_param(MODE_AUTOMATIC);
-			grab_automatic_params(value);
-		}
-		if (buf[i] == '\0')
-			break;
-		i++;
-	}
-	
-	log_message("\tgot %d args", param_number);
+	return access(COMPRESSED_FILE_REL(IMAGE_LOCATION "/"), R_OK) == 0 ||
+	       access(IMAGE_LOCATION "/" LIVE_LOCATION_REL, R_OK) == 0;
 }
 
-
-int stage1_mode = 0;
-
-int get_param(int i)
+enum return_type create_IMAGE_LOCATION(char *location_full)
 {
-#ifdef SPAWN_INTERACTIVE
-	static int fd = 0;
-	char buf[5000];
-	char * ptr;
-	int nb;
-
-	if (fd <= 0) {
-		fd = open(interactive_fifo, O_RDONLY);
-		if (fd == -1)
-			return (stage1_mode & i);
-		fcntl(fd, F_SETFL, O_NONBLOCK);
-	}
-
-	if (fd > 0) {
-		if ((nb = read(fd, buf, sizeof(buf))) > 0) {
-			buf[nb] = '\0';
-			ptr = buf;
-			while ((ptr = strstr(ptr, "+ "))) {
-				if (!strncmp(ptr+2, "expert", 6)) set_param(MODE_EXPERT);
-				if (!strncmp(ptr+2, "rescue", 6)) set_param(MODE_RESCUE);
-				ptr++;
-			}
-			ptr = buf;
-			while ((ptr = strstr(ptr, "- "))) {
-				if (!strncmp(ptr+2, "expert", 6)) unset_param(MODE_EXPERT);
-				if (!strncmp(ptr+2, "rescue", 6)) unset_param(MODE_RESCUE);
-				ptr++;
-			}
-		}
-	}
-#endif
-
-	return (stage1_mode & i);
-}
+	struct stat statbuf;
+	int offset = strncmp(location_full, IMAGE_LOCATION_DIR, sizeof(IMAGE_LOCATION_DIR) - 1) == 0 ? sizeof(IMAGE_LOCATION_DIR) - 1 : 0;
+	char *with_arch = asprintf_("%s/%s", location_full, ARCH);
 
-char * get_param_valued(char *param_name)
-{
-	int i;
-	for (i = 0; i < param_number ; i++)
-		if (!strcmp(params[i].name, param_name))
-			return params[i].value;
+	log_message("trying %s", with_arch);
 
-	return NULL;
-}
+	if (stat(with_arch, &statbuf) == 0 && S_ISDIR(statbuf.st_mode))
+		location_full = with_arch;
 
-void set_param_valued(char *param_name, char *param_value)
-{
-	params[param_number].name = param_name;
-	params[param_number].value = param_value;
-	param_number++;
-}
+	log_message("assuming %s is a mirror tree", location_full + offset);
 
-void set_param(int i)
-{
-	stage1_mode |= i;
-	if (i == MODE_RESCUE) {
-		set_param_valued("special_stage2", "rescue");
-		set_param(MODE_SPECIAL_STAGE2);
-	}
-}
+	unlink(IMAGE_LOCATION);
+	if (symlink(location_full + offset, IMAGE_LOCATION) != 0)
+		return RETURN_ERROR;
 
-void unset_param(int i)
-{
-	stage1_mode &= ~i;
+	return RETURN_OK;
 }
 
-// warning, many things rely on the fact that:
-// - when failing it returns 0
-// - it stops on first non-digit char
-int charstar_to_int(const char * s)
+int ramdisk_possible(void)
 {
-	int number = 0;
-	while (*s && isdigit(*s)) {
-		number = (number * 10) + (*s - '0');
-		s++;
+	if (total_memory() > (IS_RESCUE ? MEM_LIMIT_RESCUE : MEM_LIMIT_DRAKX))
+		return 1;
+	else {
+		log_message("warning, ramdisk is not possible due to low mem!");
+		return 0;
 	}
-	return number;
-}
-
-off_t file_size(const char * path)
-{
-	struct stat statr;
-	if (stat(path, &statr))
-		return -1;
-        else
-                return statr.st_size;
-}
-
-int total_memory(void)
-{
-	int value;
-
-	/* drakx powered: use /proc/kcore and rounds every 4 Mbytes */
-	value = 4 * ((int)((float)file_size("/proc/kcore") / 1024 / 1024 / 4 + 0.5));
-	log_message("Total Memory: %d Mbytes", value);
-
-	return value;
 }
 
-
-int ramdisk_possible(void)
+int compressed_image_preload(void)
 {
-	if (total_memory() > (IS_RESCUE ? MEM_LIMIT_RESCUE : MEM_LIMIT_RAMDISK))
+	if (total_memory() > (IS_RESCUE ? MEM_LIMIT_RESCUE_PRELOAD : MEM_LIMIT_DRAKX_PRELOAD))
 		return 1;
 	else {
-		log_message("warning, ramdisk is not possible due to low mem!");
+		log_message("warning, not preloading compressed due to low mem");
 		return 0;
 	}
 }
 
-
-enum return_type copy_file(char * from, char * to, void (*callback_func)(int overall))
+enum return_type save_fd(int from_fd, char * to, void (*callback_func)(int overall))
 {
-        FILE * f_from, * f_to;
+        FILE * f_to;
         size_t quantity __attribute__((aligned(16))), overall = 0;
         char buf[4096] __attribute__((aligned(4096)));
         int ret = RETURN_ERROR;
 
-        log_message("copy_file: %s -> %s", from, to);
-
-        if (!(f_from = fopen(from, "rb"))) {
-                log_perror(from);
-                return RETURN_ERROR;
-        }
-
         if (!(f_to = fopen(to, "w"))) {
                 log_perror(to);
                 goto close_from;
-                return RETURN_ERROR;
         }
 
         do {
-                if ((quantity = fread(buf, 1, sizeof(buf), f_from)) > 0) {
+		quantity = read(from_fd, buf, sizeof(buf));
+		if (quantity > 0) {
                         if (fwrite(buf, 1, quantity, f_to) != quantity) {
                                 log_message("short write (%s)", strerror(errno));
                                 goto cleanup;
                         }
-                }
+                } else if (quantity == -1) {
+			log_message("an error occured: %s", strerror(errno));
+			goto cleanup;
+		}
+
                 if (callback_func) {
                         overall += quantity;
                         callback_func(overall);
                 }
-        } while (!feof(f_from) && !ferror(f_from) && !ferror(f_to));
-
-        if (ferror(f_from) || ferror(f_to)) {
-                log_message("an error occured: %s", strerror(errno));
-                goto cleanup;
-        }
+        } while (quantity);
 
         ret = RETURN_OK;
 
  cleanup:
         fclose(f_to);
  close_from:
-        fclose(f_from);
+        close(from_fd);
 
         return ret;
 }
 
-static void save_stuff_for_rescue(void)
-{
-        copy_file("/etc/resolv.conf", STAGE2_LOCATION "/etc/resolv.conf", NULL);
-}
-
-enum return_type load_ramdisk_fd(int ramdisk_fd, int size)
+enum return_type copy_file(char * from, char * to, void (*callback_func)(int overall))
 {
-	BZFILE * st2;
-	char * ramdisk = "/dev/ram3"; /* warning, verify that this file exists in the initrd, and that root=/dev/ram3 is actually passed to the kernel at boot time */
-	int ram_fd;
-	char buffer[32768];
-	int z_errnum;
-	char * wait_msg = "Loading program into memory...";
-	int bytes_read = 0;
-	int actually;
-	int seems_ok = 0;
-
-	st2 = BZ2_bzdopen(ramdisk_fd, "r");
-
-	if (!st2) {
-		log_message("Opening compressed ramdisk: %s", BZ2_bzerror(st2, &z_errnum));
-		stg1_error_message("Could not open compressed ramdisk file.");
-		return RETURN_ERROR;
-	}
+        int from_fd;
 
-	ram_fd = open(ramdisk, O_WRONLY);
-	if (ram_fd == -1) {
-		log_perror(ramdisk);
-		stg1_error_message("Could not open ramdisk device file.");
-		return RETURN_ERROR;
-	}
-	
-	init_progression(wait_msg, size);
+	log_message("copy_file: %s -> %s", from, to);
 
-	while ((actually = BZ2_bzread(st2, buffer, sizeof(buffer))) > 0) {
-		seems_ok = 1;
-		if (write(ram_fd, buffer, actually) != actually) {
-			log_perror("writing ramdisk");
-			remove_wait_message();
-			return RETURN_ERROR;
-		}
-		update_progression((int)((bytes_read += actually) / RAMDISK_COMPRESSION_RATIO));
-	}
+	from_fd = open(from, O_RDONLY);
+	if (from_fd != -1) {
+		return save_fd(from_fd, to, callback_func);
+	} else {
+                log_perror(from);
+                return RETURN_ERROR;
+        }
+}
 
-	if (!seems_ok) {
-		log_message("reading compressed ramdisk: %s", BZ2_bzerror(st2, &z_errnum));
-		BZ2_bzclose(st2); /* opened by gzdopen, but also closes the associated fd */
-		close(ram_fd);
-		remove_wait_message();
-		stg1_error_message("Could not uncompress second stage ramdisk. "
-				   "This is probably an hardware error while reading the data. "
-				   "(this may be caused by a hardware failure or a Linux kernel bug)");
-		return RETURN_ERROR;
-	}
+enum return_type mount_compressed_image(char *compressed_image,  char *location_mount)
+{
+	if (lomount(compressed_image, location_mount, NULL, 1)) {
+                stg1_error_message("Could not mount compressed loopback :(.");
+                return RETURN_ERROR;
+        }
+	return RETURN_OK;
+}
 
+enum return_type preload_mount_compressed_fd(int compressed_fd, int image_size, char *image_name, char *location_mount)
+{
+	int ret;
+	char *compressed_tmpfs = asprintf_("/tmp/%s", image_name);
+	char *buf = "Loading program into memory...";
+	init_progression(buf, image_size);
+	ret = save_fd(compressed_fd, compressed_tmpfs, update_progression);
 	end_progression();
+	if (ret != RETURN_OK)
+		return ret;
+	
+	return mount_compressed_image(compressed_tmpfs, location_mount);
+}
 
-	BZ2_bzclose(st2); /* opened by gzdopen, but also closes the associated fd */
-	close(ram_fd);
+enum return_type mount_compressed_image_may_preload(char *image_name, char *location_mount, int preload)
+{
+	char *compressed_image = asprintf_("%s/%s", COMPRESSED_LOCATION, image_name);
 
-	if (my_mount(ramdisk, STAGE2_LOCATION, "ext2", 1))
-		return RETURN_ERROR;
+	log_message("mount_compressed_may_preload: %s into %s (preload = %d)", compressed_image, location_mount, preload);
 
-	set_param(MODE_RAMDISK);
+        if (access(compressed_image, R_OK) != 0) return RETURN_ERROR;
 
-	if (IS_RESCUE) {
-		save_stuff_for_rescue();
-		if (umount(STAGE2_LOCATION)) {
-			log_perror(ramdisk);
+        if (preload) {
+		int compressed_fd = open(compressed_image, O_RDONLY);
+		if (compressed_fd != -1) {
+			return preload_mount_compressed_fd(compressed_fd, file_size(compressed_image), image_name, location_mount);
+		} else {
+			log_perror(compressed_image);
 			return RETURN_ERROR;
 		}
-		return RETURN_OK; /* fucksike, I lost several hours wondering why the kernel won't see the rescue if it is alreay mounted */
+	} else {
+		return mount_compressed_image(compressed_image, location_mount);
 	}
-
-	return RETURN_OK;
 }
 
-
-char * get_ramdisk_realname(void)
+enum return_type may_load_compressed_image(void)
 {
-	char img_name[500];
-	char * stg2_name = get_param_valued("special_stage2");
-	char * begin_img = RAMDISK_LOCATION;
-	char * end_img = "_stage2.bz2";
-
-	if (!stg2_name)
-		stg2_name = "mdkinst";
-
-	if (IS_RESCUE)
-		stg2_name = "rescue";
-	
-	strcpy(img_name, begin_img);
-	strcat(img_name, stg2_name);
-	strcat(img_name, end_img);
-
-	return strdup(img_name);
+	if (!IS_RESCUE && access(IMAGE_LOCATION "/" LIVE_LOCATION_REL, R_OK) == 0) {
+		/* LIVE install */
+		return RETURN_OK;
+	} else {
+		/* compressed install */
+		return mount_compressed_image_may_preload(COMPRESSED_NAME(""), STAGE2_LOCATION, compressed_image_preload());
+	}
 }
 
-
-enum return_type load_ramdisk(void)
+enum return_type load_compressed_fd(int fd, int size)
 {
-	int st2_fd;
-        off_t size;
-	char img_name[500];
-
-	strcpy(img_name, IMAGE_LOCATION);
-	strcat(img_name, get_ramdisk_realname());
-
-	log_message("trying to load %s as a ramdisk", img_name);
+	return preload_mount_compressed_fd(fd, size, COMPRESSED_NAME(""), STAGE2_LOCATION);
+}
 
-	st2_fd = open(img_name, O_RDONLY); /* to be able to see the progression */
+int try_mount(char * dev, char * location)
+{
+	char device_fullname[50];
+	snprintf(device_fullname, sizeof(device_fullname), "/dev/%s", dev);
 
-	if (st2_fd == -1) {
-		log_message("open ramdisk file (%s) failed", img_name);
-		stg1_error_message("Could not open compressed ramdisk file (%s).", img_name);
-		return RETURN_ERROR;
-	}
+	if (my_mount(device_fullname, location, "auto", 0) == -1) {
+                return 1;
+        }
 
-	if ((size = file_size(img_name)) == -1)
-		return RETURN_ERROR;
-	else
-		return load_ramdisk_fd(st2_fd, size);
+        return 0;
 }
 
-/* pixel's */
-void * memdup(void *src, size_t size)
+#ifndef DISABLE_DISK
+int get_disks(char *** names, char *** models)
 {
-	void * r;
-	r = malloc(size);
-	memcpy(r, src, size);
-	return r;
-}
+	char ** ptr;
+	int count = 0;
 
+	my_modprobe("ide_disk", ANY_DRIVER_TYPE, NULL);
+	my_modprobe("sd_mod", ANY_DRIVER_TYPE, NULL);
 
-static char ** my_env = NULL;
-static int env_size = 0;
+	get_medias(DISK, names, models, BUS_ANY);
 
-void handle_env(char ** env)
-{
-	char ** ptr = env;
+	ptr = *names;
 	while (ptr && *ptr) {
+		count++;
 		ptr++;
-		env_size++;
 	}
-	my_env = malloc(sizeof(char *) * 100);
-	memcpy(my_env, env, sizeof(char *) * (env_size+1));
-}
 
-char ** grab_env(void) {
-	return my_env;
+        return count;
 }
+#endif
 
-void add_to_env(char * name, char * value)
+#ifndef DISABLE_CDROM
+int get_cdroms(char *** names, char *** models)
 {
-	char tmp[500];
-	sprintf(tmp, "%s=%s", name, value);
-	my_env[env_size] = strdup(tmp);
-	env_size++;
-	my_env[env_size] = NULL;
-}
-
+	char ** ptr;
+	int count = 0;
 
-char ** list_directory(char * direct)
-{
-	char * tmp[50000]; /* in /dev there can be many many files.. */
-	int i = 0;
-	struct dirent *ep;
-	DIR *dp = opendir(direct);
-	while (dp && (ep = readdir(dp))) {
-		if (strcmp(ep->d_name, ".") && strcmp(ep->d_name, "..")) {
-			tmp[i] = strdup(ep->d_name);
-			i++;
-		}
-	}
-	if (dp)
-		closedir(dp);
-	tmp[i] = NULL;
-	return memdup(tmp, sizeof(char*) * (i+1));
-}
+	my_modprobe("ide_cd_mod", ANY_DRIVER_TYPE, NULL);
+	my_modprobe("sr_mod", ANY_DRIVER_TYPE, NULL);
 
+	get_medias(CDROM, names, models, BUS_ANY);
 
-int string_array_length(char ** a)
-{
-	int i = 0;
-	if (!a)
-		return -1;
-	while (a && *a) {
-		a++;
-		i++;
+	ptr = *names;
+	while (ptr && *ptr) {
+		count++;
+		ptr++;
 	}
-	return i;
-}
 
-int kernel_version(void)
-{
-        struct utsname val;
-        if (uname(&val)) {
-                log_perror("uname failed");
-                return -1;
-        }
-        return charstar_to_int(val.release + 2);
+	return count;
 }
+#endif
 
 char * floppy_device(void)
 {
         char ** names, ** models;
-	my_insmod("floppy", ANY_DRIVER_TYPE, NULL, 0);
-        int fd = open("/dev/fd0", O_RDONLY|O_NONBLOCK);
+        int fd;
+	my_modprobe("floppy", ANY_DRIVER_TYPE, NULL);
+        fd = open("/dev/fd0", O_RDONLY|O_NONBLOCK);
         if (fd != -1) {
                 char drivtyp[17];
                 if (!ioctl(fd, FDGETDRVTYP, (void *)drivtyp)) {
@@ -502,36 +286,10 @@ char * floppy_device(void)
                 close(fd);
         }
         log_message("seems that you don't have a regular floppy drive");
-        my_insmod("sd_mod", ANY_DRIVER_TYPE, NULL, 0);
+        my_modprobe("sd_mod", ANY_DRIVER_TYPE, NULL);
 	get_medias(FLOPPY, &names, &models, BUS_ANY);
 	if (names && *names)
                 return asprintf_("/dev/%s", *names);
         else
-                return "/dev/fd0";
-}
-
-char * asprintf_(const char *msg, ...)
-{
-        int n;
-        char * s;
-        va_list arg_ptr;
-        va_start(arg_ptr, msg);
-        n = vsnprintf(0, 1000000, msg, arg_ptr);
-        va_start(arg_ptr, msg);
-        if ((s = malloc(n + 1))) {
-                vsnprintf(s, n + 1, msg, arg_ptr);
-                va_end(arg_ptr);
-                return s;
-        }
-        va_end(arg_ptr);
-        return strdup("");
-}
-
-int scall_(int retval, char * msg, char * file, int line)
-{
-	char tmp[5000];
-        sprintf(tmp, "%s(%s:%d) failed", msg, file, line);
-        if (retval)
-                log_perror(tmp);
-        return retval;
+                return NULL;
 }