<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">#!/usr/bin/env perl
# 
# SlugImage : Manipulate NSLU2 firmware images
#             Dwayne Fontenot (jacques)
#             Rod Whitby (rwhitby)
#	      www.nslu2-linux.org
#
# Copyright (c) 2004, 2006, Dwayne Fontenot &amp; Rod Whitby
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 
# Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# Neither the name of the NSLU2-Linux Development Team nor the names
# of its contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#

use strict;
use warnings;

use Getopt::Long qw(:config no_ignore_case);
use POSIX qw(tmpnam);

my($debug) = 0;
my($quiet) = 0;
my($flash_start)    = 0x50000000;
my($flash_len)      = 0x00800000;
my($block_size)     = 0x00020000;
my($kernel_offset)  = 0x00060000;
my($kernel_size)    = 0x00100000;
my($ramdisk_offset) = 0x00160000;
my(@cleanup);

# The last 70 bytes of the SercommRedBootTrailer (i.e. excluding MAC
# address).  Needed to create an image with an empty RedBoot partition
# since the Sercomm upgrade tool checks for this trailer.
# http://www.nslu2-linux.org/wiki/Info/SercommRedBootTrailer
my @sercomm_redboot_trailer = (0x4573, 0x4372, 0x4d6f, 0x006d, 0x0001,
       0x0400, 0x3170, 0x5895, 0x0010, 0x0000, 0x0000, 0x0000, 0x0000,
       0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
       0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0003, 0x2300,
       0x0063, 0x0000, 0x7320, 0x7245, 0x6f43, 0x6d4d);

# There's a 16 byte Sercomm trailer at the end of the flash. It is used
# by RedBoot to detect a Sercomm flash layout and to configure the
# Sercomm upgrade system.
# http://www.nslu2-linux.org/wiki/Info/SercommFlashTrailer
my @sercomm_flash_trailer = (0x0100, 0x0000, 0x6323, 0xf790, 0x5265,
                             0x4f63, 0x4d6d, 0xb400);

# Take $data, and pad it out to $total_len bytes, appending 0xff's.
sub padBytes {
    my($data,$total_len) = @_;

    # 0xFF is used to pad, as it's the erase value of the flash.
    my($pad_char) = pack("C",0xff);
    my($pad_len) = $total_len - length($data);

    # A request for negative padding is indicative of a logic error ...
    if (length($data) &gt; $total_len) {
	die sprintf("padBytes error: data (%d) is longer than total_len (%d)", length($data), $total_len);
    }

    return $data . ($pad_char x $pad_len);
}

# Return the next multiple of block_size larger than or equal to $data_len.
sub paddedSize {
    my($data_len) = @_;

    use integer;
    return (($data_len - 1) / $block_size) * $block_size + $block_size;
}

# Return the number of block_size blocks required to hold $data_len.
sub numBlocks {
    my($data_len) = @_;

    use integer;
    return (($data_len - 1) / $block_size) + 1;
}

# Pack the name, address, size and optional skip regions of a partition entry into binary form.
sub createPartitionEntry {
    my($name, $flash_base, $size, $skips) = @_;
    my $entry;

    my($zero_long) = 0x0000;

    # Pack the partition entry according to the format that RedBoot (and the MTD partition parsing code) requires.
    $entry = pack("a16N5x212N2",$name,$flash_base,$zero_long,$size,$zero_long,$zero_long,$zero_long,$zero_long);

    # Optionally put a skip header into the padding area.
    if (defined $skips) {
	my $i = scalar(@$skips);
	foreach my $region (@$skips) {
	    substr($entry, -8 - 12*$i, 12) =
		pack("a4N2", "skip", $region-&gt;{'offset'}, $region-&gt;{'size'});
	    $i--;
	}
    }

    return $entry;
}

# Parse partition entry and return anon array ref [$name, $offset, $size, $skip] or return 0 on partition terminator.
sub parsePartitionEntry {
    my($partition_entry) = @_;

    my($entry_len) = 0x100;
    length($partition_entry) eq $entry_len or die "parsePartitionEntry: partition entry length is not $entry_len!\n";

    # Unpack the partition table entry, saving those values in which we are interested.
    my($name, $flash_base, $size, $dummy_long, $padding, $skips);
    ($name, $flash_base, $dummy_long, $size, $dummy_long, $dummy_long, $padding, $dummy_long, $dummy_long) =
	unpack("a16N5a212N2",$partition_entry);

    # A partition entry starting with 0xFF terminates the table.
    if (unpack("C", $name) eq 0xff) {
	# %%% FIXME: This should only skip, not terminate. %%%
	$debug and print "Found terminator for &lt;FIS directory&gt;\n";
	return 0;
    }

    # Remove trailing nulls from the partition name.
    $name =~ s/\000+//;

    # Extract the skip regions out of the padding area.
    $padding =~ s/^\000+//;
    $padding =~ s/\000*skip(........)\000*/$1/g;
    $padding =~ s/\000+$//;

    # Store the skip regions in an array for later use.
    while (length($padding)) {
	my $region = {};
	($region-&gt;{'offset'}, $region-&gt;{'size'}) =
	    unpack("N2", $padding);
	$debug and printf("Found skip region at 0x%05X, size 0x%05X\n",
			  $region-&gt;{'offset'}, $region-&gt;{'size'});
	push(@$skips, $region);
	$padding = substr($padding,8);
    }

    return [$name, $flash_base - $flash_start, $size, $skips];
}

# Return partition table from data is one exists, otherwise return 0.
sub findPartitionTable {
    my($data_buf) = @_;

    unpack("a7", $data_buf) eq 'RedBoot' or return 0;
    return substr($data_buf, 0, 0x1000)
}

# Parse partition table and return array of anonymous array references ([$name, $offset, $size, $skips], ...).
sub parsePartitionTable {
    my($partition_table) = @_;

    my(@partitions, $fields_ref);
    my($entry_len) = 0x100;
    my($partition_count) = 0;

    # Loop through the fixed size partition table entries, and store the entries in @partitions.
    # %%% FIXME: This doesn't handle the case of a completely full partition table. %%%
    while ($fields_ref = parsePartitionEntry(substr($partition_table, $partition_count * $entry_len, $entry_len))) {
	$debug and printf("Found &lt;%s&gt; at 0x%08X (%s)%s\n", $fields_ref-&gt;[0], $fields_ref-&gt;[1],
			  ($fields_ref-&gt;[2] &gt;= $block_size ?
			   sprintf("%d blocks", numBlocks($fields_ref-&gt;[2])) :
			   sprintf("0x%05X bytes", $fields_ref-&gt;[2])),
			  (defined $fields_ref-&gt;[3] ?
			   sprintf(" [%s]",
				   join(", ",
					map { sprintf("0x%05X/0x%05X", $_-&gt;{'offset'},$_-&gt;{'size'}) }
					@{$fields_ref-&gt;[3]})) :
			   ""));
	$partitions[$partition_count++] = $fields_ref;
    }
    return(@partitions);
}

# Create an empty jffs2 block.
sub jffs2Block {
    return padBytes(pack("N3", 0x19852003, 0x0000000c, 0xf060dc98), $block_size);
}

# Write out $data to $filename,
sub writeOut {
    my($data, $filename) = @_;

    open FILE,"&gt;$filename" or die "Can't open file \"$filename\": $!\n";

    if (defined($data)) { print FILE $data;}

    close FILE or die "Can't close file \"$filename\": $!\n";
}

# Not used at the moment.
sub trailerData {
    my($product_id)       = 0x0001;
    my($protocol_id)      = 0x0000;
    my($firmware_version) = 0x2325;
    my($unknown1)         = 0x90f7;
    my($magic_number)     = 'eRcOmM';
    my($unknown2)         = 0x00b9;

    return pack("n4a6n",$product_id,$protocol_id,$firmware_version,$unknown1,$magic_number,$unknown2);
}

# Print the contents of the Sercomm RedBoot trailer.
sub printRedbootTrailer {
    my($redboot_data) = @_;

    my($correct_redboot_len) = 0x40000;
    my($redboot_data_len) = length($redboot_data);

    if ($redboot_data_len != $correct_redboot_len) {
	printf("Redboot length (0x%08X) is not 0x%08X\n", $redboot_data_len, $correct_redboot_len);
	return;
    }

    # The trailer is the last 80 bytes of the redboot partition.
    my($redboot_trailer) = substr($redboot_data, -80);

    writeOut($redboot_trailer, 'RedbootTrailer');

    my($mac_addr0, $mac_addr1, $mac_addr2, $unknown, $prefix, $ver_ctrl, $down_ctrl, $hid, $hver, $prodid, $prodidmask,
       $protid, $protidmask, $funcid, $funcidmask, $fver, $cseg, $csize, $postfix) =
	   unpack("n3Na7n2a32n10a7",$redboot_trailer);

    printf("MAC address is %04X%04X%04X\n", $mac_addr0, $mac_addr1, $mac_addr2);
    printf("unknown: %08X\n", $unknown);
    printf("%s:%04X:%04X:%s\n", $prefix, $ver_ctrl, $down_ctrl, $postfix);
    printf("VerControl: %04X\nDownControl: %04X\n", $ver_ctrl, $down_ctrl);
    printf("hid: %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X %04X\n", unpack("n16", $hid));
    printf("Hver: %04X\nProdID: %04X\nProtID: %04X\nFuncID: %04X\nFver: %04X\nCseg: %04X\nCsize: %04X\n",
	   $hver, $prodid, $protid, $funcid, $fver, $cseg, $csize);
}

# remove the optional Loader partition
sub removeOptionalLoader {
    my($partitions_ref) = @_;

    my $index;
    my $count = 0;
    map {
	if (not defined $index) {
	    if ($_-&gt;{'name'} eq "Loader") {
		$index = $count;
	    }
	    $count++;
	}
    } @$partitions_ref;
    
    defined $index or die "Cannot find the Loader partition\n";

    splice(@$partitions_ref, $index, 1);

    # Set fixed offsets and sizes for Kernel and Ramdisk
    map {
	if ($_-&gt;{'name'} eq 'Kernel') {
	    $_-&gt;{'offset'}   = $kernel_offset;
	    $_-&gt;{'size'}     = $kernel_size;
	    $_-&gt;{'variable'} = 0;
	}
	if ($_-&gt;{'name'} eq 'Ramdisk') {
	    $_-&gt;{'offset'}   = $ramdisk_offset;
	}
    } @$partitions_ref;

    return;
}


# populate @partitions based on the firmware's partition table
sub spliceFirmwarePartitions {
    my($firmware_buf, $partitions_ref) = @_;

    # we know that partition table, if it exists, begins at start of 'FIS directory' and has max length 0x1000
    my($partition_table);
    map {
	$_-&gt;{'name'} eq 'FIS directory' and
	    $partition_table = findPartitionTable(substr($firmware_buf, $_-&gt;{'offset'}, $_-&gt;{'size'}));
    } @$partitions_ref;

    # return 0 here if no partition table in FIS directory
    return if not $partition_table;

    my @new_partitions = parsePartitionTable($partition_table);

    # Remove the optional second stage bootloader if it is not found in the FIS directory.
    if (not grep { $_-&gt;[0] eq 'Loader' } @new_partitions) {
	removeOptionalLoader($partitions_ref);
    }

    my($partition_count) = 0;
    my($splice) = 0;
    map {

	# Skip pseudo partitions.
	while (($partition_count &lt; scalar(@$partitions_ref)) and
	       $partitions_ref-&gt;[$partition_count]-&gt;{'pseudo'}) {
	    $debug and printf("Skipped &lt;%s&gt; (pseudo partition)\n", $partitions_ref-&gt;[$partition_count]-&gt;{'name'});
	    $partition_count++;
	}

	# If we are in a variable area, and we haven't reached the end of it,
	# then splice in another partition for use by the later code.
	if ($splice and ($partitions_ref-&gt;[$partition_count]-&gt;{'name'} ne $_-&gt;[0])) {
	    $debug and printf("Splicing new partition &lt;%s&gt; before &lt;%s&gt;\n",
			      $_-&gt;[0], $partitions_ref-&gt;[$partition_count]-&gt;{'name'});
	    splice(@{$partitions_ref}, $partition_count, 0, ({'name' =&gt; "",'variable'=&gt;1,'header'=&gt;0}));
	}

	my $partition = $partitions_ref-&gt;[$partition_count];

	# Variable partitions can be overridden by the real FIS directory
	if ($partition-&gt;{'variable'}) {

	    # Only override the filename if the partition name is not set or doesn't match
	    if ($partition-&gt;{'name'} ne $_-&gt;[0]) {

		if (length($partition-&gt;{'name'})) {
		    $debug and printf("Overwriting &lt;%s&gt; with &lt;%s&gt;\n",
				      $partitions_ref-&gt;[$partition_count]-&gt;{'name'}, $_-&gt;[0]);
		}

		$partition-&gt;{'name'} = $_-&gt;[0];
		$partition-&gt;{'file'} = $_-&gt;[0];
	    }

	    # Set the offset, size and skips based on the real partition table
	    $partition-&gt;{'offset'} = $_-&gt;[1];
	    $partition-&gt;{'size'}   = $_-&gt;[2];
	    $partition-&gt;{'skips'}  = $_-&gt;[3];

	    $debug and printf("Locating &lt;%s&gt; at 0x%08X (%s)\n",
			      $partition-&gt;{'name'}, $partition-&gt;{'offset'},
			      ($partition-&gt;{'size'} &gt;= $block_size ?
			       sprintf("%d blocks", numBlocks($partition-&gt;{'size'})) :
			       sprintf("0x%05X bytes", $partition-&gt;{'size'})));

	    $splice = 1;
	}

	# Fixed partitions cannot be overridden
	else {
	    ($partition-&gt;{'name'} eq $_-&gt;[0]) or
		die "Unexpected partition &lt;",$_-&gt;[0],"&gt; (expecting &lt;",$partition-&gt;{'name'},"&gt;)\n";

	    $debug and printf("Locating &lt;%s&gt; at 0x%08X (%s)\n",
			      $partition-&gt;{'name'}, $partition-&gt;{'offset'},
			      ($partition-&gt;{'size'} &gt;= $block_size ?
			       sprintf("%d blocks", numBlocks($partition-&gt;{'size'})) :
			       sprintf("0x%05X bytes", $partition-&gt;{'size'})));
	    
	    $splice = 0;
	}
	
	$partition_count++;

    } @new_partitions;

    return;
}

# Read in an 8MB firmware file, and store the data into @partitions.
# Note that the data is only stored in a partition if 'offset' and 'size' are defined,
# and it does not already have data stored in it.
sub readInFirmware {
    my($filename, $partitions_ref) = @_;

    my($firmware_buf);

    open FILE,$filename or die "Can't find firmware image \"$filename\": $!\n";
    read FILE,$firmware_buf,$flash_len or die "Can't read $flash_len bytes from \"$filename\": $!\n";
    close FILE or die "Can't close \"$filename\": $!\n";

    $debug and printf("Read 0x%08X bytes from \"%s\"\n", length($firmware_buf), $filename);

    spliceFirmwarePartitions($firmware_buf, $partitions_ref);

    # Read the parts of the firmware file into the partitions table.
    map {
	if (defined $_-&gt;{'offset'} and defined $_-&gt;{'size'}) {

	    if (defined $_-&gt;{'data'}) {
		$debug and printf("Not overwriting data in &lt;%s&gt;\n", $_-&gt;{'name'});
	    }
	    else {

		# Slurp up the data, based on whether a header and/or data is present or not
		if ($_-&gt;{'header'}) {

		    # Read the length, and grab the data based on the length.
		    my($data_len) = unpack("N", substr($firmware_buf, $_-&gt;{'offset'}));

		    # A length of 0xFFFFFFFF means that the area is not initialised
		    if ($data_len != 0xFFFFFFFF) {
			$debug and printf("Found header size of 0x%08X bytes for &lt;%s&gt;\n", $data_len, $_-&gt;{'name'});
			$_-&gt;{'data'} = substr($firmware_buf, $_-&gt;{'offset'} + $_-&gt;{'header'}, $data_len);
		    }
		}
		elsif ($_-&gt;{'pseudo'} and not defined $_-&gt;{'file'} and
		       (substr($firmware_buf, $_-&gt;{'offset'}, $_-&gt;{'size'}) eq
			(pack("C", 0xff) x $_-&gt;{'size'}))) {
		    $debug and printf("Skipping empty pseudo partition &lt;%s&gt;\n", $_-&gt;{'name'});
		}
		else {

		    # Grab the whole partition, using the maximum size.
		    $_-&gt;{'data'} = substr($firmware_buf, $_-&gt;{'offset'}, $_-&gt;{'size'});
		}

		# If skip regions are defined, remove them from the data.
		if (defined $_-&gt;{'skips'}) {
		    my $removed = 0;
		    foreach my $region (@{$_-&gt;{'skips'}}) {
			if (($region-&gt;{'offset'} &gt; 0) or
			    not ($_-&gt;{'header'} &gt; 0)) {
			    $debug and printf("Removing 0x%05X bytes from offset 0x%05X\n",
					      $region-&gt;{'size'}, $region-&gt;{'offset'});
			    $region-&gt;{'data'} = substr($_-&gt;{'data'}, $region-&gt;{'offset'} - $removed, $region-&gt;{'size'}, '');
			}
			$removed += $region-&gt;{'size'};
		    }
		}

		$quiet or defined $_-&gt;{'data'} and printf("Read %s into &lt;%s&gt;\n",
							  (length($_-&gt;{'data'}) &gt;= $block_size ?
							   sprintf("%d blocks", numBlocks(length($_-&gt;{'data'}))) :
							   sprintf("0x%05X bytes", length($_-&gt;{'data'}))), $_-&gt;{'name'});
	    }
	}
    } @$partitions_ref;
}

# Write the partition data stored in memory out into the files associated with each.
sub writeOutFirmwareParts {
    my(@partitions) = @_;

    # Write out the parts of the firmware file.
    map {

	# We can only write if 'data' and 'file' are defined.
	if (defined $_-&gt;{'file'} and defined $_-&gt;{'data'} and length($_-&gt;{'data'})) {
	    writeOut($_-&gt;{'data'}, $_-&gt;{'file'});
	    $quiet or printf("Wrote 0x%08X bytes from &lt;%s&gt; into \"%s\"\n",
			      length($_-&gt;{'data'}), $_-&gt;{'name'}, $_-&gt;{'file'});
	}
	else {
	    $debug and printf("Skipping &lt;%s&gt; (%s)\n", $_-&gt;{'name'},
			      (not defined $_-&gt;{'file'}) ?
			      "no filename specified" :
			      "no data to write");
	}

    } @partitions;

    return;
}

# Read in the partition data from the files associated with each and store in memory.
sub readInFirmwareParts {
    my(@partitions) = (@_);
    
    undef $/; # we want to slurp

    map {

	my $file = $_-&gt;{'file'};
	if (defined $file) {
	    open FILE,$file or die "Can't find firmware part \"$file\": $!\n";

	    # Slurp in the data
	    $_-&gt;{'data'} = &lt;FILE&gt;;

	    # close the file
	    close FILE or die "Can't close file \"$file\": $!\n";

	    # Optionally byteswap the data
	    if ($_-&gt;{'byteswap'}) {
		# Byte swap the data (which has to be padded to a multiple of 4 bytes).
		$_-&gt;{'data'} = pack("N*", unpack("V*", $_-&gt;{'data'}.pack("CCC", 0)));
	    }

	    # Keep track of the actual size.
	    my $size;

	    if ($_-&gt;{'header'}) {
		if ($_-&gt;{'pseudo'}) {
		    $size = $_-&gt;{'header'} + length($_-&gt;{'data'});
		}
		else {
		    $size = paddedSize($_-&gt;{'header'} + length($_-&gt;{'data'}));
		}
	    }
	    elsif (not $_-&gt;{'pseudo'}) {
		$size = paddedSize(length($_-&gt;{'data'}));
	    }
	    else {
		$size = length($_-&gt;{'data'});
	    }

	    # Check to make sure the file contents are not too large.
	    if (defined $_-&gt;{'size'} and ($size &gt; $_-&gt;{'size'})) {
		die sprintf("Ran out of flash space in &lt;%s&gt; - %s too large.\n", $_-&gt;{'name'},
			    sprintf("0x%05X bytes", ($size - $_-&gt;{'size'})));
	    }

	    # If the partition does not have a fixed size, the calculate the size.
	    if (not defined $_-&gt;{'size'}) {
		$_-&gt;{'size'} = $size;
	    }

	    # Keep the user appraised ...
	    $quiet or printf("Read 0x%08X bytes from \"%s\" into &lt;%s&gt; (%s / %s)%s\n",
			     length($_-&gt;{'data'}), $_-&gt;{'file'}, $_-&gt;{'name'},
			     ($size &gt;= $block_size ?
			      sprintf("%d blocks", numBlocks($size)) :
			      sprintf("0x%05X bytes", $size)),
			     ($_-&gt;{'size'} &gt;= $block_size ?
			      sprintf("%d blocks", numBlocks($_-&gt;{'size'})) :
			      sprintf("0x%05X bytes", $_-&gt;{'size'})),
			     ($_-&gt;{'byteswap'} ? " (byte-swapped)" : ""));
	}

    } @partitions;

    return;
}

# layoutPartitions : this function must be ugly - it needs to verify RedBoot, SysConf, Kernel, Ramdisk, and
#     FIS directory partitions exist, are in the correct order, and do not have more data than can fit in
#     their lengths (fixed for all but Ramdisk, which has a minimum length of one block).
#     If Rootdisk and/or Userdisk exist, it must also verify that their block padded lengths are not
#     too great for the available space.
# input : an array of hashes, some of which are populated with data
# output: same reference with start and size (partition not data) also populated. this populated structure
#         can then be passed to buildPartitionTable() to generate the actual partition table data
sub layoutPartitions {
    my(@partitions) = @_;

    # Find the kernel partition, and save a pointer to it for later use
    my $kernel;
    map { ($_-&gt;{'name'} eq "Kernel") &amp;&amp; ($kernel = $_); } @partitions;
    $kernel or die "Couldn't find the kernel partition\n";

    # Find the last variable size partition, and save a pointer to it for later use
    my $lastdisk;
    my $directory_offset;
    my $curdisk = $partitions[0];
    map {
	if (not defined $lastdisk) {
	    if ($_-&gt;{'name'} eq "FIS directory") {
		$lastdisk = $curdisk;
		$directory_offset = $_-&gt;{'offset'};
	    }
	    else {
		$curdisk = $_;
	    }
	}
    } @partitions;

    $lastdisk or die "Couldn't find the last variable size partition\n";

    $debug and printf("Last variable size partition is &lt;%s&gt;\n", $lastdisk-&gt;{'name'});

    #
    # here we go through the $partitions array ref and fill in all the values
    #

    # This points to where the next partition should be placed.
    my $pointer = $flash_start;

    map {

	$debug and printf("Pointer is 0x%08X\n", $pointer);

	# Determine the start and offset of the current partition.
	if (defined $_-&gt;{'offset'}) {
	    $_-&gt;{'start'} = $flash_start + $_-&gt;{'offset'};
	    # Check for running past the defined start of the partition.
	    if (($pointer &gt; $_-&gt;{'start'}) and not $_-&gt;{'pseudo'}) {
		die sprintf("Ran out of flash space before &lt;%s&gt; - %s too large.\n", $_-&gt;{'name'},
			    sprintf("0x%05X bytes", ($pointer - $_-&gt;{'start'})));
	    }
	}

	# If offset is not defined, then calculate it.
	else {
	    $_-&gt;{'start'} = $pointer;
	    $_-&gt;{'offset'} = $_-&gt;{'start'} - $flash_start;
	}

	my $size = defined $_-&gt;{'data'} ? length($_-&gt;{'data'}) : 0;

	# Add skip regions for the partitions with headers.
	if ($_-&gt;{'header'} &gt; 0) {
	    # Define the skip region for the initial Sercomm header.
	    push(@{$_-&gt;{'skips'}},
		 { 'offset' =&gt; 0, 'size' =&gt; $_-&gt;{'header'}, 'data' =&gt; undef });
	    # Allow for the Sercomm header to be prepended to the data.
	    $size += $_-&gt;{'header'};

	    # Determine if the partition overlaps the ramdisk boundary.
	    if (($_-&gt;{'offset'} &lt; $ramdisk_offset) and
		(($_-&gt;{'offset'} + $size) &gt; $ramdisk_offset)) {
		# Define the skip region for the inline Sercomm header.
		push(@{$_-&gt;{'skips'}},
		     { 'offset' =&gt; ($ramdisk_offset - $_-&gt;{'offset'}), 'size' =&gt; 16,
		       'data' =&gt; pack("N4", $block_size) });
		# Allow for the Sercomm header to be inserted in the data.
		$size += 16;
	    }
	}

	# Partitions without headers cannot have skip regions.
	elsif (($_-&gt;{'offset'} &lt;= $ramdisk_offset) and
	       (($_-&gt;{'offset'} + $size) &gt; $ramdisk_offset)) {
	    # Pad the kernel until it extends past the ramdisk offset.
	    push(@{$kernel-&gt;{'skips'}},
		 { 'offset' =&gt; ($ramdisk_offset - $kernel-&gt;{'offset'}), 'size' =&gt; 16,
		   'data' =&gt; pack("N4", $block_size) });
	    $kernel-&gt;{'size'} = $ramdisk_offset - $kernel-&gt;{'offset'} + $block_size;
	    $kernel-&gt;{'data'} = padBytes($kernel-&gt;{'data'},
					 $kernel-&gt;{'size'} - $kernel-&gt;{'header'} - 16);
	    $_-&gt;{'offset'} = $ramdisk_offset + $block_size;
	    $_-&gt;{'start'} = $flash_start + $_-&gt;{'offset'};
	    $pointer = $_-&gt;{'start'};
	    $debug and printf("Extending kernel partition past ramdisk offset.\n");
	}

	# If this is the last variable size partition, then fill the rest of the space.
	if ($_-&gt;{'name'} eq $lastdisk-&gt;{'name'}) {
	    $_-&gt;{'size'} = paddedSize($directory_offset + $flash_start - $pointer);
	    $debug and printf("Padding last variable partition &lt;%s&gt; to 0x%08X bytes\n", $_-&gt;{'name'}, $_-&gt;{'size'});
	}

	die sprintf("Partition size not defined in &lt;%s&gt;.\n", $_-&gt;{'name'})
	    unless defined $_-&gt;{'size'};

	# Extend to another block if required.
	if ($size &gt; $_-&gt;{'size'}) {
	    if ($_-&gt;{'name'} eq $lastdisk-&gt;{'name'}) {
		die sprintf("Ran out of flash space in &lt;%s&gt; - %s too large.\n", $_-&gt;{'name'},
			    sprintf("0x%05X bytes", ($size - $_-&gt;{'size'})));
	    }
	    $_-&gt;{'size'} = $size;
	    printf("Extending partition &lt;%s&gt; to 0x%08X bytes\n", $_-&gt;{'name'}, $_-&gt;{'size'});
	}

	# Keep the user appraised ...
	$debug and printf("Allocated &lt;%s&gt; from 0x%08X to 0x%08X (%s / %s)\n",
			  $_-&gt;{'name'}, $_-&gt;{'start'}, $_-&gt;{'start'} + $_-&gt;{'size'},
			  ($size &gt;= $block_size ?
			   sprintf("%d blocks", numBlocks($size)) :
			   sprintf("0x%05X bytes", $size)),
			  ($_-&gt;{'size'} &gt;= $block_size ?
			   sprintf("%d blocks", numBlocks($_-&gt;{'size'})) :
			   sprintf("0x%05X bytes", $_-&gt;{'size'})));

	# Check to make sure we have not run out of room.
	if (($_-&gt;{'start'} + $_-&gt;{'size'}) &gt; ($flash_start + $flash_len)) {
	    die "Ran out of flash space in &lt;", $_-&gt;{'name'}, "&gt;\n";
	}

	$debug and printf("Moving pointer from 0x%08X to 0x%08X (0x%08X + 0x%08X)\n",
			  $pointer, paddedSize($_-&gt;{'start'} + $_-&gt;{'size'}),
			  $_-&gt;{'start'}, $_-&gt;{'size'});

	# Move the pointer up, in preparation for the next partition.
	$pointer = paddedSize($_-&gt;{'start'} + $_-&gt;{'size'});

    } @partitions;

    return;
}

sub buildPartitionTable {
    my(@partitions) = @_;

    my($flash_start) = 0x50000000;
    my($partition_data) = '';

    map {

	# Collate the partition data for all known partitions.
	if (not $_-&gt;{'pseudo'} and defined $_-&gt;{'offset'} and defined $_-&gt;{'size'}) {

	    # Pack and append the binary table entry for this partition.
	    $partition_data .= createPartitionEntry($_-&gt;{'name'}, $_-&gt;{'offset'} + $flash_start,
						    $_-&gt;{'size'}, $_-&gt;{'skips'});

	    # If this is the FIS directory, then write the partition table data into it.
	    if ($_-&gt;{'name'} eq "FIS directory") {
		# Explicitly terminate the partition data.
		$partition_data .= pack("C",0xff) x 0x100;
		$_-&gt;{'data'} = padBytes($partition_data, $_-&gt;{'size'});
	    }

	    my $size = length($_-&gt;{'data'});

	    # Keep the user appraised ...
	    $debug and printf("Table entry &lt;%s&gt; from 0x%08X to 0x%08X (%s / %s)%s\n",
			      $_-&gt;{'name'}, $_-&gt;{'start'}, $_-&gt;{'start'} + $_-&gt;{'size'},
			      ($size &gt;= $block_size ?
			       sprintf("%d blocks", numBlocks($size)) :
			       sprintf("0x%05X bytes", $size)),
			      ($_-&gt;{'size'} &gt;= $block_size ?
			       sprintf("%d blocks", numBlocks($_-&gt;{'size'})) :
			       sprintf("0x%05X bytes", $_-&gt;{'size'})),
			      (defined $_-&gt;{'skips'} ?
			       sprintf("\nTable entry &lt;%s&gt; skip %s", $_-&gt;{'name'},
				       join(", ",
					    map { sprintf("0x%08X to 0x%08X", $_-&gt;{'offset'},
							  $_-&gt;{'offset'} + $_-&gt;{'size'} - 1) }
					    @{$_-&gt;{'skips'}})) :
			       "")
			      );
	}
	else {
	    $debug and print "No table entry required for &lt;", $_-&gt;{'name'}, "&gt;\n";
	}

    } @partitions;

    return;
}

sub writeOutFirmware {
    my($filename, @partitions) = @_;

    # Clear the image to start.
    my $image_buf = "";

    map {

	# We can only write a partition if it has an offset, a size, and some data to write.
	if (defined $_-&gt;{'offset'} and defined $_-&gt;{'size'} and defined $_-&gt;{'data'}) {

	    # Keep track of the end of the image.
	    my $end_point = length($image_buf);

	    # If the next partition is well past the end of the current image, then pad it.
	    if ($_-&gt;{'offset'} &gt; $end_point) {
		$image_buf .= padBytes("", $_-&gt;{'offset'} - $end_point);
		$quiet or printf("Padded %s before &lt;%s&gt; in \"%s\"\n",
				 ((length($image_buf) - $end_point) &gt;= $block_size ?
				  sprintf("%d blocks", numBlocks(length($image_buf) - $end_point)) :
				  sprintf("0x%05X bytes", length($image_buf) - $end_point)),
				 $_-&gt;{'name'}, $filename);
	    }

	    # If the next parition is before the end of the current image, then rewind.
	    elsif ($_-&gt;{'offset'} &lt; $end_point) {
		$debug and printf("Rewound %s before &lt;%s&gt; in \"%s\"\n",
				  (($end_point - $_-&gt;{'offset'}) &gt;= $block_size ?
				   sprintf("%d blocks", numBlocks($end_point - $_-&gt;{'offset'})) :
				   sprintf("0x%05X bytes", $end_point - $_-&gt;{'offset'})),
				  $_-&gt;{'name'}, $filename);
# 		if (($end_point - $_-&gt;{'offset'}) &gt;= $block_size) {
# 		    die "Allocation error: rewound a full block or more ...\n";
# 		}
	    }

	    # If skip regions are defined, add them to the data.
	    if (defined $_-&gt;{'skips'}) {
		my $added = 0;
		foreach my $region (@{$_-&gt;{'skips'}}) {
		    if (($region-&gt;{'offset'} &gt; 0) or
			not ($_-&gt;{'header'} &gt; 0)) {
			$debug and printf("Inserted 0x%05X bytes (at offset 0x%05X) into &lt;%s&gt;\n",
					  $region-&gt;{'size'}, $region-&gt;{'offset'}, $_-&gt;{'name'});
			substr($_-&gt;{'data'},
			       $region-&gt;{'offset'} + $added - $_-&gt;{'header'},
			       0, $region-&gt;{'data'});
			$added += $region-&gt;{'size'};
		    }
		}
	    }

	    # Splice the data into the image at the appropriate place, padding as required.
	    substr($image_buf, $_-&gt;{'offset'}, $_-&gt;{'size'},
		   $_-&gt;{'header'} ?
		   padBytes(pack("N4",length($_-&gt;{'data'})).$_-&gt;{'data'}, $_-&gt;{'size'}) :
		   padBytes($_-&gt;{'data'}, $_-&gt;{'size'}));
	    
	    # Keep the user appraised ...
	    $quiet or printf("Wrote %s (0x%08X to 0x%08X) from &lt;%s&gt; into \"%s\"\n",
			     ($_-&gt;{'size'} &gt;= $block_size ?
			      sprintf("%2d blocks", numBlocks($_-&gt;{'size'})) :
			      sprintf("0x%05X bytes", $_-&gt;{'size'})),
			     $_-&gt;{'offset'}, $_-&gt;{'offset'}+$_-&gt;{'size'}, $_-&gt;{'name'}, $filename);
	}

	# If we are not able to write a partition, then give debug information about why.
	else {
	    $debug and printf("Skipping &lt;%s&gt; (%s)\n", $_-&gt;{'name'},
			      (not defined $_-&gt;{'offset'}) ? "no offset defined" :
			      ((not defined $_-&gt;{'size'}) ? "no size defined" :
			       "no data available"));
	}

    } @partitions;

    # Write the image to the specified file.
    writeOut($image_buf, $filename);

    return;
}

# checkPartitionTable: sanity check partition table - for testing but might evolve into setting @partitions
#    so that we can write out jffs2 partitions from a read image
#    currently not nearly paranoid enough
sub checkPartitionTable {
    my($data) = @_;

    my($pointer) = 0;
    my($entry);

    my($name, $flash_base, $size, $done, $dummy_long, $padding);
    do {
	$entry = substr($data, $pointer, 0x100);

	($name,$flash_base,$dummy_long,$size,$dummy_long,$dummy_long,$padding,$dummy_long,$dummy_long) = unpack("a16N5x212N2",$entry);
	$name =~ s/\0//g;
	$debug and printf("pointer: %d\tname: %s%sflash_base: 0x%08X\tsize: 0x%08X\n",
			  $pointer, $name, (" " x (16 - length($name))), $flash_base, $size);
	$pointer += 0x100;
	$debug and printf("terminator: 0x%08X\n", unpack("C", substr($data, $pointer, 1)));
	if (unpack("C", substr($data, $pointer, 1)) eq 0xff) {
	    $done = 1;
	}
    } until $done;
}

sub printPartitions {
    my(@partitions) = @_;

    my($offset, $size, $skips);
    map {
#	defined $_-&gt;{'size'} ? $size = $_-&gt;{'size'} : $size = undef;

	if (defined  $_-&gt;{'size'}) {
	    $size = $_-&gt;{'size'};
	}
	else {
	    $size = undef;
	}
	if (defined  $_-&gt;{'offset'}) {
	    $offset = $_-&gt;{'offset'};
	}
	else {
	    $offset = undef;
	}
	if (defined  $_-&gt;{'skips'}) {
	    $skips = $_-&gt;{'skips'};
	}
	else {
	    $skips = undef;
	}
	printf("%s%s", $_-&gt;{'name'}, (" " x (16 - length($_-&gt;{'name'}))));
	if (defined $offset) { printf("0x%08X\t", $offset); } else { printf("(undefined)\t");   };
	if (defined $size)   { printf("0x%08X", $size); } else { printf("(undefined)"); };
	if (defined $skips) {
	    printf("\t[%s]",
		   join(", ",
			map { sprintf("0x%05X/0x%05X", $_-&gt;{'offset'}, $_-&gt;{'size'}); }
			@$skips));
	}
	printf("\n");
    } @partitions;
}

sub defaultPartitions {

    return ({'name'=&gt;'RedBoot',          'file'=&gt;'RedBoot',
	     'offset'=&gt;0x00000000,        'size'=&gt;0x00040000,
	     'variable'=&gt;0, 'header'=&gt;0,  'pseudo'=&gt;0, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'EthAddr',           'file'=&gt;undef,
	     'offset'=&gt;0x0003ffb0,        'size'=&gt;0x00000006,
	     'variable'=&gt;0, 'header'=&gt;0,  'pseudo'=&gt;1, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'SysConf',           'file'=&gt;'SysConf',
	     'offset'=&gt;0x00040000,        'size'=&gt;0x00020000,
	     'variable'=&gt;0, 'header'=&gt;0,  'pseudo'=&gt;0, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'Loader',            'file'=&gt;'apex.bin',
	     'offset'=&gt;undef,             'size'=&gt;undef,
	     'variable'=&gt;1, 'header'=&gt;16, 'pseudo'=&gt;0, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'Kernel',            'file'=&gt;'vmlinuz',
	     'offset'=&gt;undef,             'size'=&gt;undef,
	     'variable'=&gt;1, 'header'=&gt;16, 'pseudo'=&gt;0, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'Ramdisk',           'file'=&gt;'ramdisk.gz',
	     'offset'=&gt;undef,             'size'=&gt;undef,
	     'variable'=&gt;1, 'header'=&gt;16, 'pseudo'=&gt;0, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'FIS directory',     'file'=&gt;undef,
	     'offset'=&gt;0x007e0000,        'size'=&gt;0x00020000,
	     'variable'=&gt;0, 'header'=&gt;0,  'pseudo'=&gt;0, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'Loader config',	  'file'=&gt;undef,
	     'offset'=&gt;0x007f8000,        'size'=&gt;0x00004000,
	     'variable'=&gt;0, 'header'=&gt;0,  'pseudo'=&gt;1, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'Microcode',	  'file'=&gt;'NPE-B',
	     'offset'=&gt;0x007fc000,        'size'=&gt;0x00003fe0,
	     'variable'=&gt;0, 'header'=&gt;16, 'pseudo'=&gt;1, 'data'=&gt;undef, 'byteswap'=&gt;0},
	    {'name'=&gt;'Trailer',           'file'=&gt;'Trailer',
	     'offset'=&gt;0x007ffff0,        'size'=&gt;0x00000010,
	     'variable'=&gt;0, 'header'=&gt;0,  'pseudo'=&gt;1, 'data'=&gt;undef, 'byteswap'=&gt;0});
}

# Main routine starts here ...

my($unpack, $pack, $little, $fatflash, $input, $output, $redboot);
my($kernel, $sysconf, $ramdisk, $fisdir);
my($microcode, $trailer, $ethaddr, $loader);

END {
    # Remove temporary files
    for my $file (@cleanup) {
	unlink $file;
    }
}

if (!GetOptions("d|debug"       =&gt; \$debug,
		"q|quiet"       =&gt; \$quiet,
		"u|unpack"      =&gt; \$unpack,
		"p|pack"        =&gt; \$pack,
		"l|little"      =&gt; \$little,
		"F|fatflash"    =&gt; \$fatflash,
		"i|input=s"     =&gt; \$input,
		"o|output=s"    =&gt; \$output,
		"b|redboot=s"   =&gt; \$redboot,
		"k|kernel=s"    =&gt; \$kernel,
		"s|sysconf=s"   =&gt; \$sysconf,
		"r|ramdisk=s"   =&gt; \$ramdisk,
		"f|fisdir=s"    =&gt; \$fisdir,
		"m|microcode=s" =&gt; \$microcode,
		"t|trailer=s"   =&gt; \$trailer,
		"e|ethaddr=s"   =&gt; \$ethaddr,
		"L|loader=s"    =&gt; \$loader,
		) or (not defined $pack and not defined $unpack)) {
    print "Usage: slugimage &lt;options&gt;\n";
    print "\n";
    print "  [-d|--debug]			Turn on debugging output\n";
    print "  [-q|--quiet]			Turn off status messages\n";
    print "  [-u|--unpack]			Unpack a firmware image\n";
    print "  [-p|--pack]			Pack a firmware image\n";
    print "  [-l|--little]			Convert Kernel and Ramdisk to little-endian\n";
    print "  [-F|--fatflash]			Generate an image for 16MB flash\n";
    print "  [-i|--input]     &lt;file&gt;		Input firmware image filename\n";
    print "  [-o|--output]    &lt;file&gt;		Output firmware image filename\n";
    print "  [-b|--redboot]   &lt;file&gt;		Input/Output RedBoot filename\n";
    print "  [-s|--sysconf]   &lt;file&gt;		Input/Output SysConf filename\n";
    print "  [-L|--loader]    &lt;file&gt;		Second stage boot loader filename\n";
    print "  [-k|--kernel]    &lt;file&gt;		Input/Ouptut Kernel filename\n";
    print "  [-r|--ramdisk]   &lt;file&gt;		Input/Output Ramdisk filename(s)\n";
    print "  [-f|--fisdir]    &lt;file&gt;		Input/Output FIS directory filename\n";
    print "  [-m|--microcode] &lt;file&gt;		Input/Output Microcode filename\n";
    print "  [-t|--trailer]   &lt;file&gt;		Input/Output Trailer filename\n";
    print "  [-e|--ethaddr]   &lt;AABBCCDDEEFF&gt;	Set the Ethernet address\n";

    # %%% TODO %%% Document --ramdisk syntax

    exit 1;
}

my(@partitions) = defaultPartitions();

if ($pack) {
    die "Output filename must be specified\n" unless defined $output;

    # If we're creating an image and no RedBoot, SysConf partition is
    # explicitly specified, simply write an empty one as the upgrade tools
    # don't touch RedBoot and SysConf anyway.  If no Trailer is specified,
    # put in one.
    if (not defined $redboot and not -e "RedBoot") {
	$redboot = tmpnam();
	open TMP, "&gt;$redboot" or die "Cannot open file $redboot: $!";
	push @cleanup, $redboot;
	# The RedBoot partition is 256 * 1024 = 262144; the trailer we add
	# is 70 bytes.
	print TMP "\0"x(262144-70);
	# Upgrade tools check for an appropriate Sercomm trailer.
	for my $i (@sercomm_redboot_trailer) {
	    print TMP pack "S", $i;
	}
	close TMP;
    }
    if (not defined $sysconf and not -e "SysConf") {
	$sysconf = tmpnam();
	open TMP, "&gt;$sysconf" or die "Cannot open file $sysconf: $!";
	push @cleanup, $sysconf;
	# The SysConf partition is 128 * 1024 = 131072
	print TMP "\0"x131072;
	close TMP;
    }
    if (not defined $trailer and not -e "Trailer") {
	$trailer = tmpnam();
	open TMP, "&gt;$trailer" or die "Cannot open file $trailer: $!";
	push @cleanup, $trailer;
	for my $i (@sercomm_flash_trailer) {
	    print TMP pack "S", $i;
	}
	close TMP;
    }

    # If the microcode was not specified, then don't complain that it's missing.
    if (not defined $microcode and not -e "NPE-B") {
	map { ($_-&gt;{'name'} eq 'Microcode') &amp;&amp; ($_-&gt;{'file'} = undef);   } @partitions;
    }
}

# Go through the partition options, and set the names and files in @partitions
if (defined $redboot)   { map { ($_-&gt;{'name'} eq 'RedBoot')	  &amp;&amp; ($_-&gt;{'file'} = $redboot);   } @partitions; }
if (defined $sysconf)   { map { ($_-&gt;{'name'} eq 'SysConf')	  &amp;&amp; ($_-&gt;{'file'} = $sysconf);   } @partitions; }
if (defined $loader)    { map { ($_-&gt;{'name'} eq 'Loader')	  &amp;&amp; ($_-&gt;{'file'} = $loader);    } @partitions; }
if (defined $kernel)    { map { ($_-&gt;{'name'} eq 'Kernel')	  &amp;&amp; ($_-&gt;{'file'} = $kernel);    } @partitions; }
if (defined $fisdir)    { map { ($_-&gt;{'name'} eq 'FIS directory') &amp;&amp; ($_-&gt;{'file'} = $fisdir);    } @partitions; }
if (defined $microcode) { map { ($_-&gt;{'name'} eq 'Microcode')	  &amp;&amp; ($_-&gt;{'file'} = $microcode); } @partitions; }
if (defined $trailer)   { map { ($_-&gt;{'name'} eq 'Trailer')	  &amp;&amp; ($_-&gt;{'file'} = $trailer);   } @partitions; }

if (defined $little)  {
    map {
	if (($_-&gt;{'name'} eq 'Loader') or
	    ($_-&gt;{'name'} eq 'Kernel') or
	    ($_-&gt;{'name'} eq 'Ramdisk')) {
	    $_-&gt;{'byteswap'} = 1;
	}
    } @partitions;
}

if (defined $fatflash)  {
    $flash_len = 0x01000000;
    map {
	if (($_-&gt;{'name'} eq 'FIS directory') or
	    ($_-&gt;{'name'} eq 'Loader config') or
	    ($_-&gt;{'name'} eq 'Microcode') or
	    ($_-&gt;{'name'} eq 'Trailer')) {
	    $_-&gt;{'offset'} += 0x00800000;
	}
    } @partitions;
}

if (defined $ethaddr) {
    map {
	if ($_-&gt;{'name'} eq 'EthAddr') {
	    $ethaddr =~ s/://g;
	    if (($ethaddr !~ m/^[0-9A-Fa-f]+$/) or (length($ethaddr) != 12)) {
		die "Invalid ethernet address specification: '".$ethaddr."'\n";
	    }
	    $_-&gt;{'data'} = pack("H12", $ethaddr);
	}
    } @partitions;
}

if (defined $ramdisk) {

    # A single filename is used for the ramdisk filename
    if ($ramdisk !~ m/[:,]/) {
	map { ($_-&gt;{'name'} eq 'Ramdisk') &amp;&amp; ($_-&gt;{'file'} = $ramdisk); } @partitions;
    }

    # otherwise, it's a list of name:file mappings
    else {
	my @mappings = split(',', $ramdisk);

	# Find the index of the Ramdisk entry
	my $index;
	my $count = 0;
	map {
	    if (not defined $index) {
		if ($_-&gt;{'name'} eq "Ramdisk") {
		    $index = $count;
		}
		$count++;
	    }
	} @partitions;

	defined $index or die "Cannot find the Ramdisk partition\n";

	# Replace the Ramdisk entry with the new mappings
	splice(@partitions, $index, 1, map {

	    # Preserve the information from the ramdisk entry
	    my %entry = %{$partitions[$index]};

	    # Parse the mapping
	    ($_ =~ m/^([^:]+):([^:]+)(:([^:]+))?$/) or die "Invalid syntax in --ramdisk\n";
	    $entry{'name'} = $1; $entry{'file'} = $2; my $size = $4;

	    # If the mapping is not for the ramdisk, then undefine its attributes
	    if ($entry{'name'} ne 'Ramdisk') {
		$entry{'offset'} = undef;
		$entry{'size'} = undef;
		$entry{'variable'} = 1;
		$entry{'header'} = 0;
		$entry{'pseudo'} = 0;
		$entry{'data'} = undef;
		$entry{'byteswap'} = 0;
	    }

	    # Support specification of the number of blocks for empty jffs2
	    if ($entry{'file'} =~ m/^[0-9]+$/) {
		$size = $entry{'file'};
		$entry{'file'} = undef;
	    }

	    # If the user has specified a size, then respect their wishes
	    if (defined $size) {
		$entry{'size'} = $size * $block_size;
		# Create an empty partition of the requested size.
		$entry{'data'} = padBytes("", $entry{'size'} - $entry{'header'});
	    }

	    \%entry;

	} @mappings);
    }
}

# Read in the firmware image
if ($input) {
    if ($debug) {
	print "Initial partition map:\n";
	printPartitions(@partitions);
    }
    
    my $result = readInFirmware($input, \@partitions);

    if ($debug) {
	print "After reading firmware:\n";
	printPartitions(@partitions);
    }
}

# Unpack the firmware if requested
if ($unpack) {
    die "Input filename must be specified\n" unless defined $input;

#    map {
#	($_-&gt;{'name'} eq 'FIS directory') and @partitions = checkPartitionTable($_-&gt;{'data'});
#    } @partitions;

    writeOutFirmwareParts(@partitions);

}

# Pack the firmware if requested
if ($pack) {

    if (!defined $loader) {
	removeOptionalLoader(\@partitions);
    }

    if ($debug) {
	print "Initial partition map:\n";
	printPartitions(@partitions);
    }
    
    my $result = readInFirmwareParts(@partitions);

    if ($debug) {
	print "after readInFirmwareParts():\n";
	printPartitions(@partitions);
# 	map {
# 	    ($_-&gt;{'name'} eq 'RedBoot') &amp;&amp; (printRedbootTrailer($_-&gt;{'data'}));
# 	} @partitions;
    }
    
    layoutPartitions(@partitions);

    if ($debug) {
 	print "after layoutPartitions():\n";
 	printPartitions(@partitions);
    }
    
    buildPartitionTable(@partitions);

    if ($debug) {
 	print "after buildPartitionTable():\n";
 	printPartitions(@partitions);

#  	my($lastblock);
#  	map {
#  	    if ($_-&gt;{'name'} eq 'FIS directory') {
#  		$lastblock = $_-&gt;{'data'};
#  	    }
#  	} @partitions;

#  	print "checkPartitionTable():\n";
#  	checkPartitionTable($lastblock);
    }
    
    writeOutFirmware($output, @partitions);

}

exit 0;
</pre></body></html>