utils/pxelinux-options

#!/usr/bin/perl
#
# Set PXELINUX hard-coded options
#

use Socket;			# For gethostbyname
use Fcntl;
use bytes;

%option_names = (
      6 => 'domain-name-servers',
     15 => 'domain-name',
     54 => 'next-server',
    209 => 'config-file',
    210 => 'path-prefix',
    211 => 'reboottime'
    );

@fmt_oneip   = ("ip-address", \&parse_oneip, \&show_ip);
@fmt_multiip = ("ip-address-list", \&parse_multiip, \&show_ip);
@fmt_string  = ("string", \&parse_string, \&show_string);
@fmt_uint32  = ("uint32", \&parse_uint32, \&show_uint32);

%option_format = (
      6 => \@fmt_multiip,
     15 => \@fmt_string,
     54 => \@fmt_oneip,
     67 => \@fmt_string,
    209 => \@fmt_string,
    210 => \@fmt_string,
    211 => \@fmt_uint32
    );

sub parse_oneip($)
{
    my($s) = @_;
    my($name,$aliases,$addrtype,$length,@addrs) = gethostbyname($s);

    return ($addrtype == AF_INET) ? $addrs[0] : undef;
}

sub parse_multiip($)
{
    my($l) = @_;
    my $s;
    my @a = ();
    my $addr;
    my $d = '';

    foreach $s (split(/,/, $l)) {
	my($name,$aliases,$addrtype,$length,@addrs)
	    = gethostbyname($s);
	if ($addrtype == AF_INET) {
	    foreach $addr (@addrs) {
		$d .= $addr;
	    }
	}
    }

    return $d ne '' ? $d : undef;
}

sub show_ip($)
{
    my($l) = @_;

    if (length($l) & 3) {
	return undef;
    } else {
	my @h = ();
	my $i;

	for ($i = 0; $i < length($l); $i += 4) {
	    push(@h, inet_ntoa(substr($l, $i, 4)));
	}

	return join(',', @h);
    }
}

sub parse_string($)
{
    return $_[0];
}

sub show_string($)
{
    my($s) = @_;
    my $o, $i, $c;

    $o = "\'";
    for ($i = 0; $i < length($s); $i++) {
	$c = substr($s, $i, 1);
	if ($c eq "\'" || $c eq '!') {
	    $o .= "\'\\$c\'";
	} else {
	    $o .= $c;
	}
    }
    $o .= "\'";

    return $o;
}

sub parse_uint32($)
{
    my($s) = @_;

    if ($s =~ /^[0-9]+$/) {
	return pack("N", $s);
    } else {
	return undef;
    }
}

sub show_uint32($)
{
    my($l) = @_;

    if (length($l) == 4) {
	return unpack("N", $l);
    } else {
	return undef;
    }
}

sub parse_generic($)
{
    my($s) = @_;

    if ($s =~ /^[0-9a-f]{1,2}(:[0-9a-f]{1,2})*$/) {
	my $h;
	my @b = ();

	foreach $h (split(/\:/, $s)) {
	    push(@b, hex $h);
	}

	return pack("C", @b);
    } else {
	return undef;
    }
}

sub show_generic($)
{
    my($l) = @_;
    my $i;
    my @h;

    for ($i = 0; $i < length($l); $i++) {
	push(@h, sprintf("%02x", unpack("C", substr($l, $i, $1))));
    }

    return join(':', @h);
}

sub parse_option($$)
{
    my($opt, $arg) = @_;
    my $v;

    if (defined($option_format{$opt})) {
	$v = $option_format{$opt}[1]($arg);
	return $v if (defined($v));
    }

    return parse_generic($arg);
}

sub show_option($$)
{
    my($opt, $arg) = @_;
    my $v;

    if (defined($option_format{$opt})) {
	$v = $option_format{$opt}[2]($arg);
	return $v if (defined($v));
    }

    return show_generic($arg);
}

sub option_number($)
{
    my($n) = @_;

    if (defined($option_rnames{$n})) {
	return $option_rnames{$n};
    } elsif ($n =~ /^[0-9]+$/ && $n >= 1 && $n <= 254) {
	return $n+0;
    } else {
	return undef;
    }
}

sub read_optsets($)
{
    my($file) = @_;
    my $data, $bdata, $adata;
    my $patch_start = (stat($file))[7];
    my $hdroffset = 0;		# 0 means non-deep-embedded
    my $bufsize = 0;
    my $junk;
    my %hdr;

    return undef unless (seek($file, 0, SEEK_SET));
    return undef unless (read($file, $data, 48) == 48);

    my($mzmagic, $junk, $magic, $len, $flags, $boff, $blen, $aoff, $alen)
	= unpack("va[6]VVVVVVV", $data);

    if ($mzmagic == 0x5a4d) {
	# It is an EFI file... search for the magic number
	$hdroffset = 48;
	my $magic = pack("VVVV", 0x2a171ead, 0x0600e65e,
			 0x4025a4e4, 0x42388fc8);

	while (1) {
	    return undef unless (read($file, $data, 16) == 16);
	    last if ($data eq $magic);

	    $hdroffset += 16;
	}

	return undef unless (read($file, $data, 16) == 16);
	($blen, $alen, $bufsize, $junk) = unpack("VVVV", $data);

	$patch_start = $boff = $hdroffset + 32;
	$aoff = $boff + $blen;

	$hdr{'deep'} = 1;
	$hdr{'bufsize'} = $bufsize;
	$hdr{'hdroffset'} = $hdroffset;
    } else {
	# It is a BIOS PXE file

	return undef if ($magic != 0x2983c8ac);
	return undef if ($len < 7*4);

	$hdr{'deep'} = 0;
    }

    if ($blen == 0) {
	$bdata = '';
    } else {
	return undef unless (seek($file, $boff, SEEK_SET));
	return undef unless (read($file, $bdata, $blen) == $blen);
	$patch_start = $boff if ($boff < patch_start);
    }

    if ($alen == 0) {
	$adata = '';
    } else {
	return undef unless (seek($file, $aoff, SEEK_SET));
	return undef unless (read($file, $adata, $alen) == $alen);
	$patch_start = $aoff if ($aoff < $patch_start);
    }

    $hdr{'patch_start'} = $patch_start;

    return (\%hdr, $bdata, $adata);
}

sub write_optsets($$@)
{
    my($file, $hdr, $bdata, $adata) = @_;
    my $boff = 0;
    my $aoff = 0;
    my $bufsize = 0;
    my $patch_start = $hdr->{'patch_start'};
    my $len;

    $bdata .= "\xff" unless ($bdata eq '');
    $adata .= "\xff" unless ($adata eq '');

    $len = length($bdata) + length($adata);

    if (defined($hdr->{'bufsize'})) {
	return undef unless ($len <= $hdr->{'bufsize'});
    }

    return undef unless (seek($file, $patch_start, SEEK_SET));

    if (length($bdata)) {
	$boff = $patch_start;
	return undef unless (print $file $bdata);
	$patch_start += length($bdata);
    }

    if (length($adata)) {
	$aoff = $patch_start;
	return undef unless (print $file $adata);
	$patch_start += length($adata);
    }

    if ($hdr->{'deep'}) {
	return undef unless (print $file "\0" x ($hdr->{'bufsize'} - $len));
	return undef unless (seek($file, $hdr->{'hdroffset'} + 16, SEEK_SET));
	my $hdr = pack("VV", length($bdata), length($adata));
	return undef unless (print $file $hdr);
    } else {
	my $hdr = pack("VVVV", $boff, length($bdata), $aoff, length($adata));

	return undef unless (seek($file, 8+3*4, SEEK_SET));
	return undef unless (print $file $hdr);

	truncate($file, $patch_start);
    }

    return 1;
}

sub delete_option($$)
{
    my ($num, $block) = @_;
    my $o, $l, $c, $x;

    $x = 0;
    while ($x < length($block)) {
	($o, $l) = unpack("CC", substr($block, $x, 2));
	if ($o == $num) {
	    # Delete this option
	    substr($block, $x, $l+2) = '';
	} elsif ($o == 0) {
	    # Delete a null option
	    substr($block, $x, 1) = '';
	} elsif ($o == 255) {
	    # End marker - truncate block
	    $block = substr($block, 0, $x);
	    last;
	} else {
	    # Skip to the next option
	    $x += $l+2;
	}
    }

    return $block;
}

sub add_option($$$)
{
    my ($num, $data, $block) = @_;

    $block = delete_option($num, $block);

    if (length($data) == 0) {
	return $block;
    } elsif (length($data) > 255) {
	die "$0: option $num has too much data (max 255 bytes)\n";
    } else {
	return $block . pack("CC", $num, length($data)) . $data;
    }
}

sub list_options($$)
{
    my($pfx, $data) = @_;
    my $x, $o, $l;

    while ($x < length($data)) {
	($o, $l) = unpack("CC", substr($data, $x, 2));

	if ($o == 0) {
	    $x++;
	} elsif ($o == 255) {
	    last;
	} else {
	    my $odata = substr($data, $x+2, $l);
	    last if (length($odata) != $l); # Incomplete option

	    printf "%s%-20s %s\n", $pfx,
		$option_names{$o} || sprintf("%d", $o),
		show_option($o, $odata);

	    $x += $l+2;
	}
    }
}

sub usage()
{
    my $i;

    print STDERR "Usage: $0 options pxelinux.0\n";
    print STDERR "Options:\n";
    print STDERR "--before option value   -b   Add an option before DHCP data\n";
    print STDERR "--after  option value   -a   Add an option after DHCP data\n";
    print STDERR "--delete option         -d   Delete an option\n";
    print STDERR "--list                  -l   List set options\n";
    print STDERR "--dry-run               -n   Don't modify the target file\n";
    print STDERR "--help                  -h   Display this help text\n";
    print STDERR "\n";
    print STDERR "The following DHCP options are currently recognized:\n";
    printf STDERR "%-23s %-3s  %s\n", 'Name', 'Num', 'Value Format';

    foreach $i (sort { $a <=> $b } keys(%option_names)) {
	printf STDERR "%-23s %3d  %s\n",
		$option_names{$i}, $i, $option_format{$i}[0];
    }
}

%option_rnames = ();
foreach $opt (keys(%option_names)) {
    $option_rnames{$option_names{$opt}} = $opt;
}

%before   = ();
%after    = ();
@clear    = ();
$usage    = 0;
$err      = 0;
$list     = 0;
$no_write = 0;
undef $file;

while (defined($opt = shift(@ARGV))) {
    if ($opt !~ /^-/) {
	if (defined($file)) {
	    $err = $usage = 1;
	    last;
	}
	$file = $opt;
    } elsif ($opt eq '-b' || $opt eq '--before') {
	$oname = shift(@ARGV);
	$odata = shift(@ARGV);

	if (!defined($odata)) {
	    $err = $usage = 1;
	    last;
	}

	$onum = option_number($oname);
	if (!defined($onum)) {
	    print STDERR "$0: unknown option name: $oname\n";
	    $err = 1;
	    next;
	}

	$odata = parse_option($onum, $odata);
	if (!defined($odata)) {
	    print STDERR "$0: unable to parse data for option $oname\n";
	    $err = 1;
	    next;
	}

	delete $after{$onum};
	$before{$onum} = $odata;
	push(@clear, $onum);
    } elsif ($opt eq '-a' || $opt eq '--after') {
	$oname = shift(@ARGV);
	$odata = shift(@ARGV);

	if (!defined($odata)) {
	    $err = $usage = 1;
	    last;
	}

	$onum = option_number($oname);
	if (!defined($onum)) {
	    print STDERR "$0: unknown option name: $oname\n";
	    $err = 1;
	    next;
	}

	$odata = parse_option($onum, $odata);
	if (!defined($odata)) {
	    print STDERR "$0: unable to parse data for option $oname\n";
	    $err = 1;
	    next;
	}

	delete $before{$onum};
	$after{$onum} = $odata;
	push(@clear, $onum);
    } elsif ($opt eq '-d' || $opt eq '--delete') {
	$oname = shift(@ARGV);

	if (!defined($oname)) {
	    $err = $usage = 1;
	    last;
	}

	$onum = option_number($oname);
	if (!defined($onum)) {
	    print STDERR "$0: unknown option name: $oname\n";
	    $err = 1;
	    next;
	}

	push(@clear, $onum);
	delete $before{$onum};
	delete $after{$onum};
    } elsif ($opt eq '-n' || $opt eq '--no-write' || $opt eq '--dry-run') {
	$no_write = 1;
    } elsif ($opt eq '-l' || $opt eq '--list') {
	$list = 1;
    } elsif ($opt eq '-h' || $opt eq '--help') {
	$usage = 1;
    } else {
	print STDERR "Invalid option: $opt\n";
	$err = $usage = 1;
    }
}

if (!defined($file) && !$usage) {
    $err = $usage = 1;
}
if ($usage) {
    usage();
}
if ($err || $usage) {
    exit($err);
}

if (!scalar(@clear)) {
    $no_write = 1;		# No modifications requested
}

$mode = $no_write ? '<' : '+<';

open(FILE, $mode, $file)
    or die "$0: cannot open: $file: $!\n";
($hdrinfo, @data) = read_optsets(\*FILE);
if (!defined($hdrinfo)) {
    die "$0: $file: patch block not found or file corrupt\n";
}

foreach $o (@clear) {
    $data[0] = delete_option($o, $data[0]);
    $data[1] = delete_option($o, $data[1]);
}
foreach $o (keys(%before)) {
    $data[0] = add_option($o, $before{$o}, $data[0]);
}
foreach $o (keys(%after)) {
    $data[1] = add_option($o, $after{$o}, $data[1]);
}

if ($list) {
    list_options('-b ', $data[0]);
    list_options('-a ', $data[1]);
}

if (!$no_write) {
    if (!write_optsets(\*FILE, $hdrinfo, @data)) {
	die "$0: $file: failed to write options: $!\n";
    }
}

close(FILE);
exit 0;