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 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";

use client;

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

        my $conf = $server::conf;
        mkdir $conf unless -e $conf;

        my $ip;

        if ( -e "$conf/mac/$mac" ) {
                $ip = read_file "$conf/mac/$mac";
                print "RENEW $mac $ip\n";
                return $ip;
        } else {
                $ip = client::next_ip;
                print "NEW $mac $ip\n";
                write_file "$conf/mac/$mac", $ip;
        }

        my $ip_path = "$conf/ip/$ip";
        mkdir $ip_path unless -e $ip_path;

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

        symlink "$conf/mac/$mac", "$ip_path/mac";

        return $ip;
}

use log;
use config;
use pxelinux;
use client;

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

sub process_packet {
        my $sock = shift;

        server->refresh;

        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_DHCP_SERVER_IDENTIFIER()    => $server::ip, # busybox/udhcpc needs it but doesn't request
        };

        my $options = {
                DHO_SUBNET_MASK()       => $server::netmask,
                DHO_ROUTERS()           => $server::ip,
                DHO_DOMAIN_NAME()       => $server::domain_name,
                DHO_NAME_SERVERS()      => $server::ip,
                DHO_DOMAIN_NAME_SERVERS() => $server::ip,
                DHO_HOST_NAME()         => client::conf( $ip, 'hostname' ),
                DHO_BROADCAST_ADDRESS() => $server::bcast,
#               DHO_NTP_SERVERS() => '',
        };

        my @requested = split(/\s/, $dhcp->getOptionValue(DHO_DHCP_PARAMETER_REQUEST_LIST));
        warn "options ",dump( $options ), ' requested: ',dump( @requested ) if $debug;

        my @missing;
        foreach ( @requested ) {
                if ( defined $options->{$_} ) {
                        $packet->{$_} = $options->{$_};
                } else {
                        push @missing, $_;
                }
        }

        warn "W: options requested but missing: ",dump( @missing ),$/;

        foreach my $opt ( 'magic', 'config_file', 'path_prefix', 'reboot_time' ) {
                my $DH0 = eval 'DHO_PXELINUX_' . uc $opt;
                warn "DH0: $@" if $@;
                my $v = eval "\$pxelinux::$opt";
                warn "v: $@" if $@;
                next unless defined $v;
                warn "pxelinux dhcp option $opt = $DH0 = $v\n" if $debug;
                $packet->{ $DH0 } = $v;
        }

        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_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
22	dpavlin	44	use lib '..';
23	dpavlin	27	use Net::DHCP::Packet;
24			use Net::DHCP::Constants 0.67;
25	dpavlin	1
26	dpavlin	44	use server;
27	dpavlin	67	my $debug = server::debug;
28	dpavlin	1
29	dpavlin	44	if ( ! $server::ip ) {
30			my $server_ip = `/sbin/ifconfig`;
31	dpavlin	22	$server_ip =~ s/^.+?addr:([\d\.]+).*$/$1/gs;
32	dpavlin	44	$server::ip = $server_ip;
33	dpavlin	22	}
34
35	dpavlin	110	warn "server ip $server::ip range: $server::ip_from - $server::ip_to\n";
36	dpavlin	1
37	dpavlin	168	use client;
38	dpavlin	17
39	dpavlin	1	sub client_ip {
40			my ( $mac ) = @_;
41
42	dpavlin	156	my $conf = $server::conf;
43	dpavlin	17	mkdir $conf unless -e $conf;
44	dpavlin	1
45	dpavlin	177	my $ip;
46
47	dpavlin	22	if ( -e "$conf/mac/$mac" ) {
48	dpavlin	177	$ip = read_file "$conf/mac/$mac";
49	dpavlin	94	print "RENEW $mac $ip\n";
50	dpavlin	17	return $ip;
51	dpavlin	177	} else {
52			$ip = client::next_ip;
53			print "NEW $mac $ip\n";
54			write_file "$conf/mac/$mac", $ip;
55	dpavlin	17	}
56	dpavlin	1
57	dpavlin	156	my $ip_path = "$conf/ip/$ip";
58			mkdir $ip_path unless -e $ip_path;
59
60			if ( -l "$ip_path/mac" && readlink "$ip_path/mac" ne "$conf/mac/$mac" ) {
61			warn "$mac IP changed from ", readlink "$ip_path/mac", " to $ip";
62			unlink "$ip_path/mac";
63	dpavlin	146	};
64	dpavlin	177
65	dpavlin	156	symlink "$conf/mac/$mac", "$ip_path/mac";
66	dpavlin	17
67	dpavlin	1	return $ip;
68			}
69
70	dpavlin	110	use log;
71			use config;
72	dpavlin	129	use pxelinux;
73	dpavlin	160	use client;
74	dpavlin	110
75			our $file;
76	dpavlin	44	our $transaction = 0; # FIXME predictible transaction numbers
77	dpavlin	27
78	dpavlin	44	sub process_packet {
79			my $sock = shift;
80	dpavlin	1
81	dpavlin	128	server->refresh;
82
83	dpavlin	1	my $buf;
84			$sock->recv($buf, 1024);
85	dpavlin	44	my $size = 'empty';
86			$size = length($buf) . ' bytes' if defined $buf;
87	dpavlin	1
88	dpavlin	94	print "packet from ",$sock->peerhost,":",$sock->peerport," $size\n" if $debug;
89	dpavlin	44	return unless $buf;
90	dpavlin	1
91	dpavlin	44	my $dhcp = Net::DHCP::Packet->new($buf);
92			$dhcp->comment( $transaction++ );
93	dpavlin	1
94	dpavlin	67	warn "recv: ", $dhcp->toString if $debug;
95	dpavlin	1
96	dpavlin	44	my $mac = substr($dhcp->chaddr(),0,$dhcp->hlen()*2);
97			my $ip = client_ip($mac);
98	dpavlin	1
99	dpavlin	44	=for later
100	dpavlin	6
101	dpavlin	44	my $user_class = $dhcp->getOptionValue(DHO_USER_CLASS());
102	dpavlin	1
103	dpavlin	44	if ( $user_class eq 'gPXE' ) {
104			$file = $gpxe_file;
105			} elsif ( ! $file ) {
106			$file = 'undionly.kpxe';
107			}
108	dpavlin	22
109	dpavlin	44	=cut
110
111	dpavlin	110	config::for_ip( $ip );
112
113	dpavlin	44	my $packet = {
114			Op => BOOTREPLY(),
115			Hops => $dhcp->hops(),
116			Xid => $dhcp->xid(),
117			Flags => $dhcp->flags(),
118			Ciaddr => $dhcp->ciaddr(),
119			Yiaddr => $ip,
120			Siaddr => $server::ip,
121			Giaddr => $dhcp->giaddr(),
122			Chaddr => $dhcp->chaddr(),
123	dpavlin	110	File => $file,
124	dpavlin	160	DHO_DHCP_SERVER_IDENTIFIER() => $server::ip, # busybox/udhcpc needs it but doesn't request
125	dpavlin	44	};
126
127	dpavlin	160	my $options = {
128			DHO_SUBNET_MASK() => $server::netmask,
129			DHO_ROUTERS() => $server::ip,
130			DHO_DOMAIN_NAME() => $server::domain_name,
131			DHO_NAME_SERVERS() => $server::ip,
132			DHO_DOMAIN_NAME_SERVERS() => $server::ip,
133			DHO_HOST_NAME() => client::conf( $ip, 'hostname' ),
134			DHO_BROADCAST_ADDRESS() => $server::bcast,
135			# DHO_NTP_SERVERS() => '',
136			};
137
138			my @requested = split(/\s/, $dhcp->getOptionValue(DHO_DHCP_PARAMETER_REQUEST_LIST));
139	dpavlin	167	warn "options ",dump( $options ), ' requested: ',dump( @requested ) if $debug;
140
141			my @missing;
142	dpavlin	160	foreach ( @requested ) {
143	dpavlin	167	if ( defined $options->{$_} ) {
144			$packet->{$_} = $options->{$_};
145			} else {
146			push @missing, $_;
147			}
148	dpavlin	160	}
149
150	dpavlin	168	warn "W: options requested but missing: ",dump( @missing ),$/;
151	dpavlin	167
152	dpavlin	129	foreach my $opt ( 'magic', 'config_file', 'path_prefix', 'reboot_time' ) {
153			my $DH0 = eval 'DHO_PXELINUX_' . uc $opt;
154			warn "DH0: $@" if $@;
155			my $v = eval "\$pxelinux::$opt";
156			warn "v: $@" if $@;
157			next unless defined $v;
158	dpavlin	167	warn "pxelinux dhcp option $opt = $DH0 = $v\n" if $debug;
159	dpavlin	129	$packet->{ $DH0 } = $v;
160			}
161
162	dpavlin	44	my $messagetype = $dhcp->getOptionValue(DHO_DHCP_MESSAGE_TYPE());
163
164			if ($messagetype eq DHCPDISCOVER()) {
165	dpavlin	72	log::mac $mac, "DHCP DISCOVER";
166	dpavlin	44	$packet->{Comment} = $dhcp->comment();
167			$packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPOFFER();
168			} elsif ($messagetype eq DHCPREQUEST()) {
169			my $requested_ip = $dhcp->getOptionValue(DHO_DHCP_REQUESTED_ADDRESS());
170	dpavlin	110	log::mac $mac, "DHCP REQUEST $requested_ip $ip $file";
171	dpavlin	44	if ( $ip eq $requested_ip ) {
172			$packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPACK();
173			$packet->{DHO_DHCP_LEASE_TIME()} = 5 * 60; # 5 min
174			# $packet->{DHO_ROOT_PATH()} = '/exports/foobar';
175	dpavlin	27	} else {
176	dpavlin	44	$packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPNAK();
177			$packet->{DHO_DHCP_MESSAGE()} = "Bad request, expected $ip";
178	dpavlin	27	}
179	dpavlin	44	} elsif ($messagetype eq DHCPINFORM()) {
180	dpavlin	72	log::mac $mac, "DHCP INFORM ignored";
181	dpavlin	44	} else {
182	dpavlin	72	log::mac $mac, "$messagetype igored (bootp?)";
183	dpavlin	44	}
184	dpavlin	27
185	dpavlin	110	warn ">> $mac == $ip server: $server::ip", $file ? " file: $file\n" : "\n" if $debug;
186	dpavlin	27
187	dpavlin	44	$packet = new Net::DHCP::Packet( %$packet );
188	dpavlin	67	warn "send ",$packet->toString() if $debug;
189	dpavlin	27
190	dpavlin	44	my $reply = IO::Socket::INET->new(
191			LocalAddr => $server::ip,
192			LocalPort => 67,
193			Proto => "udp",
194			Broadcast => 1,
195			PeerAddr => '255.255.255.255',
196			PeerPort => 68,
197			Reuse => 1,
198			) or die "socket: $@";
199	dpavlin	1
200	dpavlin	44	my $buff = $packet->serialize();
201			$reply->send( $buff, 0 ) or die "Error sending: $!\n";
202	dpavlin	1
203	dpavlin	44	# system("arp -s $ip $mac"),
204	dpavlin	1
205	dpavlin	44	}
206	dpavlin	1
207	dpavlin	44	sub start {
208
209			my $sock = IO::Socket::INET->new(
210			LocalPort => 67,
211			# LocalAddr => 'localhost',
212			# LocalAddr => '10.0.0.100',
213			LocalAddr => '0.0.0.0',
214			Proto => 'udp',
215			ReuseAddr => 1,
216			# PeerPort => getservbyname('bootpc', 'udp'),
217			Broadcast => 1,
218			Type => SOCK_DGRAM,
219			) or die "Failed to bind to socket: $@";
220
221			print "DHCP listen on ",$sock->sockhost,":",$sock->sockport,"\n";
222
223			while (1) {
224			process_packet $sock;
225	dpavlin	1	}
226	dpavlin	44	}
227	dpavlin	1
228	dpavlin	45	warn "loaded";
229
230	dpavlin	44	1;