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 CouchDB;
use format;

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_mac_ip {
        my ( $mac, $request_ip ) = @_;

        if ( ! $mac ) {
                warn "W: no mac in requiest\n";
                return;
        }

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

        my $ip;

        if ( $ip = client::ip_from_mac( $mac ) ) {
                print "RENEW $mac $ip\n";
                client::save_ip_mac( $ip, $mac );
                return $ip;
        } elsif ( ip::in_dhcp_range( $request_ip ) || $request_ip eq '0.0.0.0' ) {
                $ip = client::next_ip( $mac );
                print "NEW $mac $ip\n";
        } else {
                $ip = $request_ip;
                client::save_ip_mac( $ip, $mac );
                warn "W: $ip out of server range $server::ip/$server::netmask\n";
        }

        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;

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

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

        $dhcp->comment( $transaction++ );

        my $mac = format::mac( substr($dhcp->chaddr(),0,$dhcp->hlen()*2) );
        my $ip = client_mac_ip($mac, $dhcp->ciaddr);

        my $hostname = $dhcp->getOptionValue(DHO_HOST_NAME);
        print "$ip ", client::conf( $ip => 'hostname', default => $hostname ), " >> /etc/hosts\n" if $hostname;

        my $audit = { mac => $mac, ip => $ip, hostname => $hostname,
                options => {
                        map {
                                ( $_ => $dhcp->getOptionValue( $_ ) )
                        } @{ $dhcp->{options_order} }
                },
        };

=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 $server;
        map { $server->{ $_ } = eval '$server::' . $_ } ( 'ip', 'netmask', 'bcast', 'domain' );

        if ( my $force = client::conf( $ip => 'dhcpd.pl' ) ) {
                eval $force;
                die "$force\n$@" if $@;
                warn "force server ", dump $server;
        }

        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},
                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 ),$/;
        $audit->{requested} = [ @requested ];
        $audit->{missing}   = [ @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());

        my @type;

        if ($messagetype eq DHCPDISCOVER()) {
                $packet->{Comment} = $dhcp->comment();
                $packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPOFFER();
                @type = qw( discover offer );
        } elsif ($messagetype eq DHCPREQUEST()) {
                @type = qw( request );
                my $requested_ip = $dhcp->getOptionValue(DHO_DHCP_REQUESTED_ADDRESS()) || $dhcp->ciaddr();
                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';
                        $type[1] = 'ack';
                } else {
                        $packet->{DHO_DHCP_MESSAGE_TYPE()} = DHCPNAK();
                        $packet->{DHO_DHCP_MESSAGE()} = "Bad request, expected $ip got $requested_ip";
                        $type[1] = 'nak';
                }
        } elsif ($messagetype eq DHCPINFORM()) {
                @type = qw( inform ignored );
        } else {
                @type = ( $messagetype, 'ignored' );
        }

        warn "# type ",dump @type;
        $audit->{type} = [ @type ];

        $audit->{response} = $packet;

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

        if ( ip::in_dhcp_range( $ip ) ) {
                my $buff = $packet->serialize();

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

                $reply->send( $buff, 0 ) or die "Error sending: $!\n";
                warn ">> $mac == $ip server: $server->{ip}", $file ? " file: $file\n" : "\n";
        } else {
                $audit->{error} = "$ip not in server range $server::ip $server::netmask - no packet sent";
                warn $audit->{error};
        }

        CouchDB::audit( @type, $audit );

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

        CouchDB::audit( 'start', { addr => $sock->sockhost, port => $sock->sockport } );

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