root/trunk/freewrt/tools/afdisk/afdisk.c

/* afdisk - automatic fdisk
 * Copyright (C) 2002 by David Roetzel <david@roetzel.de>
 *
 * 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.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <fcntl.h>

#include "detect.h"
#include "conf.h"
#include "partx86.h"

#define VERSION  "0.0.1"

/* Converts strings like "200MB" into kilobytes
 * Note that i follow the SI norm which means
 * that 1MB = 1000KB etc.
 * I assume that long is sufficient for modern
 * hard disks 
 */
long to_kbytes(const char *string) {
        int i,mult;
        long result;
        char c;

        if (string == 0) return 0; /* Maybe -1 would be more apropriate but could mess up calculations */
        for (i = 0;;i++) {
                c = *(string+i);
                if (isdigit(c)) continue;
                c = tolower(c);
                switch (c) {
                        case 'k' :
                        case '\0' : mult = 0; break;
                        case 'm' : mult = 1; break;
                        case 'g' : mult = 2; break;
                }
                break;
        }

        /* *(string+i) = '\0'; */
        result = atol(string);

        for (i = 0; i < mult; i++) result = result * 1000;

        return result;
}

/* Test if configuration makes any sense */

int check_config(const struct config *conf_ptr, struct hdlist *devices) {
        struct config conf = *conf_ptr;
        long sum = 0;
        struct partconf *curr, *ahead, *acurr, *aprev;
        struct hdlist *hdcurr;

        /* Get free space on detected hard drives */
        hdcurr = devices;
        while (hdcurr != NULL) {
                set_device((*hdcurr).dev);
                if (conf.overwrite == 0) del_part_table();
                (*hdcurr).size = get_free_space();
                sum += (*hdcurr).size;
                hdcurr = (*hdcurr).next;
        }
        if (sum < to_kbytes(conf.min_size)) {
                printf("%ld < %ld\n", sum, to_kbytes(conf.min_size));
                return -1; /* Not enough free space */
        }
        /* Copy partition data into agenda */

        curr = conf.partinfo;
        ahead = NULL;
        while (curr != NULL) {
                if (ahead == NULL) {
                        ahead = malloc(sizeof(*ahead));
                        memcpy(ahead, curr, sizeof(*ahead));
                        acurr = ahead;
                }
                else {
                        (*acurr).next = malloc(sizeof(*acurr));
                        acurr = (*acurr).next;
                        memcpy(acurr,curr,sizeof(*acurr));
                }
                curr = (*curr).next;
        }

        /* Check if there's space for the partitions that have a device specified 
         */
        hdcurr = devices;
        while (hdcurr != NULL) {
                acurr = ahead;
                while (acurr != NULL) {
                        if ((*acurr).device != NULL && strcmp((*acurr).device, (*hdcurr).dev)) {
                                if ((*hdcurr).size < to_kbytes((*acurr).min_size)) return -1; /* Not enough free space */
                                (*hdcurr).size -= to_kbytes((*acurr).min_size);
                                if (acurr == ahead) ahead = (*acurr).next;
                                else (*aprev).next = (*acurr).next;
                        }
                        else aprev = acurr;

                        acurr = (*acurr).next;
                }
                hdcurr = (*hdcurr).next;
        }

        /* And finally check, whether there is space for the other partitions */
        
        hdcurr = devices;
        while (hdcurr != NULL) {
                acurr = ahead;
                while (acurr != NULL) {
                        if ((*hdcurr).size >= to_kbytes((*acurr).min_size)) { 
                                (*hdcurr).size -= to_kbytes((*acurr).min_size);
                                if (acurr == ahead) ahead = (*acurr).next;
                                else (*aprev).next = (*acurr).next;
                        }
                        else aprev = acurr;

                        acurr = (*acurr).next;
                }
                if (ahead == NULL) break;
                hdcurr = (*hdcurr).next;
        }

        if (ahead != NULL) return -1; /* There are still partitions left, that we found no space for */
        return 0;
}


/* The function that performs the abstract partitioning 
 * 
 */

int partition(struct config *conf_ptr, struct hdlist *devices) {
        struct config conf = *conf_ptr;
        struct partconf *first, *previous, *current, *tbc_first, *tbc_curr;
        int count,tbc;
        long space, max, part;
        
        first = conf.partinfo;
        previous = NULL;
        current = first;
        count = conf.partcount;
        
        while (count > 0) {
                tbc_first = NULL;
                if (devices == NULL) return -1;
                set_device((*devices).dev);
                tbc = 0;
                if (conf.overwrite == 0) del_part_table();
                space = get_free_space();
                /* Check which partitions _have to_ be created on current device */
                while (current != NULL) {
                        if ((*current).device != NULL && strcmp((*current).device, (*devices).dev)) {
                                if (to_kbytes((*current).min_size) > space) return -2; /* Not enough free space, which should never happen */
                                /* enlist in current devices-to-be-created list */
                                if (tbc_first == NULL) {
                                        tbc_first = current;
                                        tbc_curr = tbc_first;
                                }
                                else {
                                        (*tbc_curr).next = current;
                                        tbc_curr = current;
                                }
                                tbc++;
                                /* remove from list of partitions */
                                if (current == first) first = (*current).next;
                                else (*previous).next = (*current).next;
                                (*current).next = NULL;
                                /* Decrement free space */
                                space -= to_kbytes((*current).min_size);
                                /* Decrement counter of partitions that have no device yet */
                                count--;
                        }
                        else previous = current;
                        if (previous == NULL) current = first;
                        else current = (*previous).next;
                }
                /* Check if there is space left for other partitions */
                current = first;
                previous = NULL;
                while (current != NULL) {
                        if (to_kbytes((*current).min_size) <= space) { 
                                /* enlist in current devices-to-be-created list */
                                if (tbc_first == NULL) {
                                        tbc_first = current;
                                        tbc_curr = tbc_first;
                                }
                                else {
                                        (*tbc_curr).next = current;
                                        tbc_curr = current;
                                }
                                tbc++;
                                /* remove from list of partitions */
                                if (current == first) first = (*current).next;
                                else (*previous).next = (*current).next;
                                (*current).next = NULL;
                                /* Decrement free space */
                                space -= to_kbytes((*current).min_size);
                                /* Decrement counter of partitions that have no device yet */
                                count--;
                        }
                        else previous = current;
                        if (previous == NULL) current = first;
                        else current = (*previous).next;
                }
                /* so right now tbc_first includes all partitions we want to create on the current device
                 * so let's see if we can use all the free space */
                tbc_curr = tbc_first;
                part = space / tbc;
                while (tbc_curr != NULL) {
                        if ((*tbc_curr).max_size != NULL) {
                                if (to_kbytes((*tbc_curr).max_size) > to_kbytes((*tbc_curr).min_size)) {
                                        max = to_kbytes((*tbc_curr).max_size) - to_kbytes((*tbc_curr).min_size);
                                        if (max > part) max = part;
                                        (*tbc_curr).exact_size = malloc(11);
                                        sprintf((*tbc_curr).exact_size, "%ld", max + to_kbytes((*tbc_curr).min_size));
                                        space -= max;
                                }
                                else (*tbc_curr).exact_size = (*tbc_curr).min_size;
                                tbc--;
                                if (tbc > 0) part = space / tbc;
                        }
                        tbc_curr = (*tbc_curr).next;
                }
                tbc_curr = tbc_first;
                while (tbc_curr != NULL) {
                        if ((*tbc_curr).max_size == NULL) {
                                (*tbc_curr).exact_size = malloc(11);
                                sprintf((*tbc_curr).exact_size, "%ld", part + to_kbytes((*tbc_curr).min_size));
                        }
                        tbc_curr = (*tbc_curr).next;
                }
                /* Now we can add the partitions */
                tbc_curr = tbc_first;
                while (tbc_curr != NULL) {
                        if ((*tbc_curr).exact_size == NULL) (*tbc_curr).exact_size = (*tbc_curr).min_size;
                        add_partition((*tbc_curr).type, tbc_curr->name, to_kbytes((*tbc_curr).exact_size), 0);
                        tbc_curr = (*tbc_curr).next;
                }
                /* Now let's write the partition table */
                if (write_part_table(conf_ptr) != 0) return -3;
                devices = (*devices).next;
        }
        
        return 0;       
}

int main(int argc, char **argv) {
        /* Test Code */
        int i,ret;
        struct hdlist *list,*head;
        struct config *conf;
        
        //list = detect(&hdcount);
        list = malloc(sizeof(struct hdlist));
        head = list;

        if(argc != 2) {
                printf("Usage\n%s <device>\n", argv[0]);
                return -1;
        }
        if(strncmp(argv[1], "/dev/", 5) != 0) {
                list->dev = malloc(sizeof(char) * (strlen("/dev/") + strlen(argv[1]) + 1));
                snprintf(list->dev, sizeof(char)*(strlen("/dev/")+strlen(argv[1])+1), "/dev/%s", argv[1]);
        } else {
                list->dev = argv[1];
        }
        if((i=open(list->dev, O_RDWR)) == -1) {
                printf("Error opening device %s, maybe no privileges?\n", list->dev);
                return -1;
        } else {
                close(i);
        }

        // printf("Using disk %s. This will destroy ALL data on the device!\nContinue? [Ny] ");
        // fflush(stdout);
        // i = getchar();
        // while(getchar() != '\n');
        // if(i != 'y' && i != 'Y') return 0;



        conf = get_config();

        ret = check_config(conf, head);

        if (check_config(conf, head) == -1) {
                printf("Can't proceed with current configuration : Not enough free disk space.\n");
                return -1;
        }

        i = partition(conf, head);

        switch (i) {
                case -1: printf("No devices to partition.\n"); break;
                case -2: printf("Not enough free disk space.\n"); break;
                case -3: printf("Error writing partition table."); break;
        }

        return i;
}