lib/PXElator/dhcpd.pm

package dhcpd;

=head1 dhcpd

start with:

 perl -Ilib/PXElator -Ilib -Mdhcpd -e start

based on L<http://www.perlmonks.org/index.pl?node_id=325248>

=cut

use strict;
use warnings;

use autodie;

use IO::Socket::INET;
use File::Slurp;
use Data::Dump qw/dump/;
use Net::Ping;

use lib '..';
use Net::DHCP::Packet;
use Net::DHCP::Constants 0.67;

use server;
my $debug = server::debug;

if ( ! $server::ip ) {
        my $server_ip = `/sbin/ifconfig`;
        $server_ip =~ s/^.+?addr:([\d\.]+).*$/$1/gs;
        $server::ip = $server_ip;
}

warn "server ip $server::ip range: $server::ip_from - $server::ip_to\n";

my $addr = $server::ip_from;

sub client_ip {
        my ( $mac ) = @_;

        my $conf = "$server::base_dir/conf/$server::ip";
        mkdir $conf unless -e $conf;

        if ( -e "$conf/mac/$mac" ) {
                my $ip = read_file "$conf/mac/$mac";
                print "RENEW $mac $ip\n";
                return $ip;
        }

        mkdir $_ foreach grep { ! -e $_ } map { "$conf/$_" } ( 'ip', 'mac' );

        my $p = Net::Ping->new;

        my $prefix = $server::ip;
        $prefix =~ s{\.\d+$}{.};
        my $ip = $prefix . $addr;
        while ( -e "conf/ip/$ip" || $p->ping( $ip ) ) {
                $ip = $prefix . $addr++;
                die "all addresses allocated!" if $addr == $server::ip_to;
        }

        write_file "$conf/mac/$mac", $ip;
        if ( -l "$conf/ip/$ip" && readlink "$conf/ip/$ip" ne "$conf/mac/$mac") {
                unlink     "$conf/ip/$ip";
                symlink    "$conf/mac/$mac", "$conf/ip/$ip";
                warn "$mac IP changed to $ip";
        }

        print "$mac NEW $ip\n";

        return $ip;
}

use log;
use config;

our $file;
our $transaction = 0; # FIXME predictible transaction numbers

sub process_packet {
        my $sock = shift;

        my $buf;
        $sock->recv($buf, 1024);
        my $size = 'empty';
        $size = length($buf) . ' bytes' if defined $buf;

        print "packet from ",$sock->peerhost,":",$sock->peerport," $size\n" if $debug;
        return unless $buf;

        my $dhcp = Net::DHCP::Packet->new($buf);
        $dhcp->comment( $transaction++ );

        warn "recv: ", $dhcp->toString if $debug;

        my $mac = substr($dhcp->chaddr(),0,$dhcp->hlen()*2);
        my $ip = client_ip($mac);

=for later

        my $user_class = $dhcp->getOptionValue(DHO_USER_CLASS());

        if ( $user_class eq 'gPXE' ) {
                $file = $gpxe_file;
        } elsif ( ! $file ) {
                $file = 'undionly.kpxe';
        }

=cut

        config::for_ip( $ip );

        my $packet = {
                Op              => BOOTREPLY(),
                Hops    => $dhcp->hops(),
                Xid             => $dhcp->xid(),
                Flags   => $dhcp->flags(),
                Ciaddr  => $dhcp->ciaddr(),
                Yiaddr  => $ip,
                Siaddr  => $server::ip,
                Giaddr  => $dhcp->giaddr(),
                Chaddr  => $dhcp->chaddr(),
                File    => $file,

                DHO_PXELINUX_MAGIC()       => 0xF100747E,
                DHO_PXELINUX_CONFIG_FILE() => 'pxelinux.cfg/default',
                DHO_PXELINUX_PATH_PREFIX() => 'live-helper/tftpboot/',
                DHO_PXELINUX_REBOOT_TIME() => 5, # default: 300 s
        };

        my $messagetype = $dhcp->getOptionValue(DHO_DHCP_MESSAGE_TYPE());

        if ($messagetype eq DHCPDISCOVER()) {
                log::mac $mac, "DHCP DISCOVER";
                $packet->{Comment} = $dhcp->comment();
                $packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPOFFER();
        } elsif ($messagetype eq DHCPREQUEST()) {
                my $requested_ip = $dhcp->getOptionValue(DHO_DHCP_REQUESTED_ADDRESS());
                log::mac $mac, "DHCP REQUEST $requested_ip $ip $file";
                if ( $ip eq $requested_ip ) {
                        $packet->{DHO_DHCP_MESSAGE_TYPE()}      = DHCPACK();
                        $packet->{DHO_DHCP_LEASE_TIME()}        = 5 * 60; # 5 min
#                       $packet->{DHO_DHCP_SERVER_IDENTIFIER()} = $server::ip;          # FIXME
                        $packet->{DHO_SUBNET_MASK()}            = '255.255.255.0';
                        $packet->{DHO_ROUTERS()}                = $server::ip;
#                       $packet->{DHO_DOMAIN_NAME()}            = 'pxelator.lan';
#                       $packet->{DHO_NAME_SERVERS()}           = $server::ip;
#                       $packet->{DHO_ROOT_PATH()}              = '/exports/foobar';
                } else {
                        $packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPNAK();
                        $packet->{DHO_DHCP_MESSAGE()} = "Bad request, expected $ip";
                }
        } elsif ($messagetype eq DHCPINFORM()) {
                log::mac $mac, "DHCP INFORM ignored";
        } else {
                log::mac $mac, "$messagetype igored (bootp?)";
        }

        warn ">> $mac == $ip server: $server::ip", $file ? " file: $file\n" : "\n" if $debug;

        $packet = new Net::DHCP::Packet( %$packet );
        warn "send ",$packet->toString() if $debug;

        my $reply = IO::Socket::INET->new(
                LocalAddr => $server::ip,
                LocalPort => 67,
                Proto => "udp",
                Broadcast => 1,
                PeerAddr => '255.255.255.255',
                PeerPort => 68,
                Reuse => 1,
        ) or die "socket: $@";

        my $buff = $packet->serialize();
        $reply->send( $buff, 0 ) or die "Error sending: $!\n";

#       system("arp -s $ip $mac"),

}

sub start {

        my $sock = IO::Socket::INET->new(
                LocalPort       => 67,
#               LocalAddr       => 'localhost',
#               LocalAddr       => '10.0.0.100',
                LocalAddr       => '0.0.0.0',
                Proto           => 'udp',
                ReuseAddr       => 1,
#               PeerPort        => getservbyname('bootpc', 'udp'),
                Broadcast       => 1,
                Type            => SOCK_DGRAM,
        ) or die "Failed to bind to socket: $@";

        print "DHCP listen on ",$sock->sockhost,":",$sock->sockport,"\n";

        while (1) {
                process_packet $sock;
        }
}

warn "loaded";

1;
1	dpavlin	48	package dhcpd;
2	dpavlin	1
3	dpavlin	44	=head1 dhcpd
4	dpavlin	1
5	dpavlin	44	start with:
6
7			perl -Ilib/PXElator -Ilib -Mdhcpd -e start
8
9			based on L<http://www.perlmonks.org/index.pl?node_id=325248>
10
11			=cut
12
13	dpavlin	1	use strict;
14			use warnings;
15
16	dpavlin	22	use autodie;
17
18	dpavlin	1	use IO::Socket::INET;
19	dpavlin	17	use File::Slurp;
20	dpavlin	1	use Data::Dump qw/dump/;
21	dpavlin	36	use Net::Ping;
22	dpavlin	1
23	dpavlin	44	use lib '..';
24	dpavlin	27	use Net::DHCP::Packet;
25			use Net::DHCP::Constants 0.67;
26	dpavlin	1
27	dpavlin	44	use server;
28	dpavlin	67	my $debug = server::debug;
29	dpavlin	1
30	dpavlin	44	if ( ! $server::ip ) {
31			my $server_ip = `/sbin/ifconfig`;
32	dpavlin	22	$server_ip =~ s/^.+?addr:([\d\.]+).*$/$1/gs;
33	dpavlin	44	$server::ip = $server_ip;
34	dpavlin	22	}
35
36	dpavlin	110	warn "server ip $server::ip range: $server::ip_from - $server::ip_to\n";
37	dpavlin	1
38	dpavlin	45	my $addr = $server::ip_from;
39	dpavlin	17
40	dpavlin	1	sub client_ip {
41			my ( $mac ) = @_;
42
43	dpavlin	69	my $conf = "$server::base_dir/conf/$server::ip";
44	dpavlin	17	mkdir $conf unless -e $conf;
45	dpavlin	1
46	dpavlin	22	if ( -e "$conf/mac/$mac" ) {
47			my $ip = read_file "$conf/mac/$mac";
48	dpavlin	94	print "RENEW $mac $ip\n";
49	dpavlin	17	return $ip;
50			}
51	dpavlin	1
52	dpavlin	17	mkdir $_ foreach grep { ! -e $_ } map { "$conf/$_" } ( 'ip', 'mac' );
53
54	dpavlin	36	my $p = Net::Ping->new;
55
56	dpavlin	44	my $prefix = $server::ip;
57	dpavlin	17	$prefix =~ s{\.\d+$}{.};
58			my $ip = $prefix . $addr;
59	dpavlin	36	while ( -e "conf/ip/$ip" \|\| $p->ping( $ip ) ) {
60	dpavlin	17	$ip = $prefix . $addr++;
61	dpavlin	45	die "all addresses allocated!" if $addr == $server::ip_to;
62	dpavlin	1	}
63
64	dpavlin	17	write_file "$conf/mac/$mac", $ip;
65	dpavlin	33	if ( -l "$conf/ip/$ip" && readlink "$conf/ip/$ip" ne "$conf/mac/$mac") {
66			unlink "$conf/ip/$ip";
67			symlink "$conf/mac/$mac", "$conf/ip/$ip";
68			warn "$mac IP changed to $ip";
69			}
70	dpavlin	17
71			print "$mac NEW $ip\n";
72
73	dpavlin	1	return $ip;
74			}
75
76	dpavlin	110	use log;
77			use config;
78
79			our $file;
80	dpavlin	44	our $transaction = 0; # FIXME predictible transaction numbers
81	dpavlin	27
82	dpavlin	44	sub process_packet {
83			my $sock = shift;
84	dpavlin	1
85			my $buf;
86			$sock->recv($buf, 1024);
87	dpavlin	44	my $size = 'empty';
88			$size = length($buf) . ' bytes' if defined $buf;
89	dpavlin	1
90	dpavlin	94	print "packet from ",$sock->peerhost,":",$sock->peerport," $size\n" if $debug;
91	dpavlin	44	return unless $buf;
92	dpavlin	1
93	dpavlin	44	my $dhcp = Net::DHCP::Packet->new($buf);
94			$dhcp->comment( $transaction++ );
95	dpavlin	1
96	dpavlin	67	warn "recv: ", $dhcp->toString if $debug;
97	dpavlin	1
98	dpavlin	44	my $mac = substr($dhcp->chaddr(),0,$dhcp->hlen()*2);
99			my $ip = client_ip($mac);
100	dpavlin	1
101	dpavlin	44	=for later
102	dpavlin	6
103	dpavlin	44	my $user_class = $dhcp->getOptionValue(DHO_USER_CLASS());
104	dpavlin	1
105	dpavlin	44	if ( $user_class eq 'gPXE' ) {
106			$file = $gpxe_file;
107			} elsif ( ! $file ) {
108			$file = 'undionly.kpxe';
109			}
110	dpavlin	22
111	dpavlin	44	=cut
112
113	dpavlin	110	config::for_ip( $ip );
114
115	dpavlin	44	my $packet = {
116			Op => BOOTREPLY(),
117			Hops => $dhcp->hops(),
118			Xid => $dhcp->xid(),
119			Flags => $dhcp->flags(),
120			Ciaddr => $dhcp->ciaddr(),
121			Yiaddr => $ip,
122			Siaddr => $server::ip,
123			Giaddr => $dhcp->giaddr(),
124			Chaddr => $dhcp->chaddr(),
125	dpavlin	110	File => $file,
126	dpavlin	114
127			DHO_PXELINUX_MAGIC() => 0xF100747E,
128			DHO_PXELINUX_CONFIG_FILE() => 'pxelinux.cfg/default',
129			DHO_PXELINUX_PATH_PREFIX() => 'live-helper/tftpboot/',
130			DHO_PXELINUX_REBOOT_TIME() => 5, # default: 300 s
131	dpavlin	44	};
132
133			my $messagetype = $dhcp->getOptionValue(DHO_DHCP_MESSAGE_TYPE());
134
135			if ($messagetype eq DHCPDISCOVER()) {
136	dpavlin	72	log::mac $mac, "DHCP DISCOVER";
137	dpavlin	44	$packet->{Comment} = $dhcp->comment();
138			$packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPOFFER();
139			} elsif ($messagetype eq DHCPREQUEST()) {
140			my $requested_ip = $dhcp->getOptionValue(DHO_DHCP_REQUESTED_ADDRESS());
141	dpavlin	110	log::mac $mac, "DHCP REQUEST $requested_ip $ip $file";
142	dpavlin	44	if ( $ip eq $requested_ip ) {
143			$packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPACK();
144			$packet->{DHO_DHCP_LEASE_TIME()} = 5 * 60; # 5 min
145			# $packet->{DHO_DHCP_SERVER_IDENTIFIER()} = $server::ip; # FIXME
146			$packet->{DHO_SUBNET_MASK()} = '255.255.255.0';
147			$packet->{DHO_ROUTERS()} = $server::ip;
148			# $packet->{DHO_DOMAIN_NAME()} = 'pxelator.lan';
149			# $packet->{DHO_NAME_SERVERS()} = $server::ip;
150			# $packet->{DHO_ROOT_PATH()} = '/exports/foobar';
151	dpavlin	27	} else {
152	dpavlin	44	$packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPNAK();
153			$packet->{DHO_DHCP_MESSAGE()} = "Bad request, expected $ip";
154	dpavlin	27	}
155	dpavlin	44	} elsif ($messagetype eq DHCPINFORM()) {
156	dpavlin	72	log::mac $mac, "DHCP INFORM ignored";
157	dpavlin	44	} else {
158	dpavlin	72	log::mac $mac, "$messagetype igored (bootp?)";
159	dpavlin	44	}
160	dpavlin	27
161	dpavlin	110	warn ">> $mac == $ip server: $server::ip", $file ? " file: $file\n" : "\n" if $debug;
162	dpavlin	27
163	dpavlin	44	$packet = new Net::DHCP::Packet( %$packet );
164	dpavlin	67	warn "send ",$packet->toString() if $debug;
165	dpavlin	27
166	dpavlin	44	my $reply = IO::Socket::INET->new(
167			LocalAddr => $server::ip,
168			LocalPort => 67,
169			Proto => "udp",
170			Broadcast => 1,
171			PeerAddr => '255.255.255.255',
172			PeerPort => 68,
173			Reuse => 1,
174			) or die "socket: $@";
175	dpavlin	1
176	dpavlin	44	my $buff = $packet->serialize();
177			$reply->send( $buff, 0 ) or die "Error sending: $!\n";
178	dpavlin	1
179	dpavlin	44	# system("arp -s $ip $mac"),
180	dpavlin	1
181	dpavlin	44	}
182	dpavlin	1
183	dpavlin	44	sub start {
184
185			my $sock = IO::Socket::INET->new(
186			LocalPort => 67,
187			# LocalAddr => 'localhost',
188			# LocalAddr => '10.0.0.100',
189			LocalAddr => '0.0.0.0',
190			Proto => 'udp',
191			ReuseAddr => 1,
192			# PeerPort => getservbyname('bootpc', 'udp'),
193			Broadcast => 1,
194			Type => SOCK_DGRAM,
195			) or die "Failed to bind to socket: $@";
196
197			print "DHCP listen on ",$sock->sockhost,":",$sock->sockport,"\n";
198
199			while (1) {
200			process_packet $sock;
201	dpavlin	1	}
202	dpavlin	44	}
203	dpavlin	1
204	dpavlin	45	warn "loaded";
205
206	dpavlin	44	1;