root/openembedded/zipitZ2BBfiles/fatroot/prepSDcard.pl

#!/usr/bin/perl
# This is a dangerous script!
# Be sure you read the README-install file and understand
# fully how you are to use this script!
#
# Not a joke. Read it, you could bork your system with this.
#
use strict;
use Getopt::Long;

my $DEVICE = "/dev/sdX"; # CHANGE ME! to your proper SD device! e.g. /dev/sdh


my $USER;
my @parts;
my $Response;
my $cmd;
my @sysutils = qw/ tar fsck.ext3 mount umount mkdir rmdir file mke2fs mkdosfs fdisk unzip /;
my $pgm=`basename $0`; chomp($pgm);

use vars qw / $opt_help $opt_fatroot $opt_tarball $opt_partitions /; #/

sub printHelp {
                print STDERR "
Usage: ${pgm} [options]

Options:
  --help -h : help, this menu.
  --partitions : prep SD card for Zipit Linux by building partitions.
  --fatroot=</path/filename> : file contents to populate into FAT16 partition.
  --tarball=</path/filename> : file contents to populate into Linux partition.

WARNING:
    THIS TOOL COULD BE DANGEROUS TO USE IF YOU DO NOT DETERMINE
    THE CORRECT DEVICE WHERE YOUR SD CARD IS LOCATED! WORKING
    WITH FILESYSTEMS AND PARTITIONS CAN BORK YOUR SYSTEM.

    READ THE INSTRUCTIONS, 'README-sdcard', AND MAKE SURE YOU KNOW
    WHAT YOU ARE DOING BEFORE PROCEEDING. IF NOT, ASK SOMEONE!!!

"; #"
}

sub collectCmdLineOpts {
my $result = GetOptions(
        'help|h'   => \$opt_help,
        'fatroot=s' => \$opt_fatroot,
        'tarball=s' => \$opt_tarball,
        'partitions'  => \$opt_partitions,
        );
        # we need at least something to work on...
        if (@ARGV || !(defined $opt_fatroot || defined $opt_tarball || defined $opt_partitions)) {
                printHelp(); exit;
        }
        exit if (${result} ne 1);
}

sub createPartitions {
        # make sure they read the README-install...
        $USER = qx/id | cut -f1 -d\\) | cut -f2 -d\\(/; chomp $USER;
        $USER !~ /root/ && die "You must be root to run this script!";
        $DEVICE =~ m:/dev/sdX: && die "'${DEVICE}' is not a proper system device for SD card!";

        # is the device name properly formed?
        if ($DEVICE !~ m:/dev/sd[a-z]$:) {
                die "Bad device name was given for DEVICE";
        }
        # does the device exist?
        $cmd = (split(/\//,$DEVICE))[2];
        $cmd = "cat /sys/block/".$cmd."/removable 2>&1";
        qx/$cmd/ !~ /1/ && do {
                print "'${DEVICE}' does not appear to be a removable device!\n";
                die "Strange device named as SD card!";
        };

        # check to see if the system tools are available to us!
        while (@sysutils) {
                my $util = shift @sysutils;
                $cmd = qx:which $util 2>&1:;
                $cmd =~ /which: no/ && die "The utility '${util}' is not installed or in your path!";
        }

        # so far all seems to be ok.
        @parts = qx/fdisk -l ${DEVICE} | grep '^\/dev'/;
        print "\nThis card contains these partitions:\n";
        print @parts;
        print "\nDo you wish to continue and re-partition?\n";
        do { print "Enter (yes/no) "; $Response = <STDIN>; } while $Response !~ /^yes$|^no$/;

        # do we go on?
        if ($Response !~ /^yes$/) { print "Aborted\n"; exit; }

        # erase the all the partitions
        print "\n";
        while (@parts) {
                my ($line,undef) = split(/\s/,pop @parts,2);
                $line =~ s/${DEVICE}//;
                if ($line gt 1) {
                        $cmd = "echo 'd\n".$line."\nw\n' | fdisk ${DEVICE}";
                } else {
                        $cmd = "echo 'd\nw\n' | fdisk ${DEVICE}";
                }
                print "Deleting partition: ${DEVICE}${line}\n";
                $line = qx/$cmd/;
        }
        print "\nAll partitions on ${DEVICE} have been removed\n";

        # create the two partitions that we need.
        # first the FAT16 partition.
        $cmd = "echo 'n\np\n1\n1\n+8M\nt\n6\nw\n' | fdisk ${DEVICE}";
        print "\nCreating FAT16 partition on ${DEVICE}1\n";
        qx/$cmd/;

        # next, all the rest of the drive is to be Linux.
        $cmd = "echo 'n\np\n2\n\n\nw\n' | fdisk ${DEVICE}";
        print "\nCreating Linux partition on remainder of ${DEVICE}\n";
        qx/$cmd/;

        # make the filesystems!
        print "\n\nFormat ${DEVICE}1 as vfat\n";
        $cmd = "mkdosfs ${DEVICE}1"; qx/$cmd/;
        print "\nFormat ${DEVICE}2 as ext3\n";
        $cmd = "mke2fs -j ${DEVICE}2"; qx/$cmd/;
}

sub fillFatPartition {
# mount it, then unzip the image.
my $mount = "mount$$";
        # validate that the image appears to be reasonable.
        my $line = qx/file -b ${opt_fatroot} 2>&1/;
        $line !~ /Zip archive data/ && do {
                print "\nERROR: ${line}";
                die "This does not look like a zipfile: ${opt_fatroot}\n\n";
        };
        # make a tmp mounting point.
        qx/mkdir $mount/;       
        # mount the drive partition.
        $line = qx/mount ${DEVICE}1 ${mount} 2>&1/;
        if ($line eq '') {
                print "\nfilling ${DEVICE}1 with the FAT16 component.\n";
                qx:rm -rf ${mount}/*:;
                @parts = qx/echo 'n' | unzip ${opt_fatroot} -d ${mount} 2>&1/;
                qx/umount $mount/;      
                print @parts;
                print "\n";
                # look for error.
                $parts[$#parts-1] =~ /\(disk full\?\)/ && do {
                        qx/rmdir $mount/;       
                        die "ERROR: Not enough room on ${DEVICE}1 for all those files!\n\n";
                }
        } else {
                print "\nERROR: ${line}";
                die "Something wrong with your SD card???\n\n";
        }
        qx/rmdir $mount/;       
}

sub fillExt3Partition {
# mount it, then un-tar the image.
my $mount = "mount$$";
        # validate that the image appears to be reasonable.
        my $line = qx/file -b -L ${opt_tarball} 2>&1/;
        $line !~ /POSIX tar archive/ && do {
                print "\nERROR: ${line}";
                die "This does not look like a proper tarball: ${opt_tarball}\n\n";
        };
        # make sure filesystem is intact.
        qx/fsck.ext3 ${DEVICE}2 -y/;
        # make a tmp mounting point.
        qx/mkdir $mount/;       
        # mount the drive partition.
        $line = qx/mount ${DEVICE}2 ${mount} 2>&1/;
        if ($line eq '') {
                print "\nfilling ${DEVICE}2 with the Linux ext3 component.\n";
                qx:rm -rf ${mount}/*:;
                @parts = qx/tar xCf ${mount} ${opt_tarball} 2>&1/;
                qx/umount $mount/;      
                print @parts;
                print "\n";
                # look for error.
                $parts[$#parts] =~ /tar: Error exit/ && do {
                        qx/rmdir $mount/;       
                        die "ERROR: Not enough room on ${DEVICE}2 for all those files!\n\n";
                }
        } else {
                print "\nERROR: ${line}";
                die "Something wrong with your SD card???\n\n";
        }
        qx/rmdir $mount/;       
}

        # process command line toggles.
        collectCmdLineOpts();
        if ($opt_help) { printHelp(); exit; }
        if ($opt_partitions) { createPartitions() }
        if ($opt_fatroot) { fillFatPartition() }
        if ($opt_tarball) { fillExt3Partition() }
        print "Success!\n\n";