lib/PXElator/client.pm

package client;

use warnings;
use strict;
use autodie;

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

use server;
use format;
use ip;

our $debug = $server::debug;

sub mkbasedir {
        my $path = shift;
        $path =~ s{(^.*)/[^/]+$}{$1};
        mkdir $path unless -d $path;
        return $path;
}

sub mac_path { $server::conf . '/mac/' . $_[0] }
sub  ip_path { $server::conf . '/ip/'  . join('/', @_) }
sub conf_value {
        my $path = shift;
        my $value;
        if ( -l $path ) {
                $value = readlink $path;
                $value =~ s{.*/([^/]+)$}{$1};
        } elsif ( -f $path ) {
                $value = read_file $path;
        } else {
                warn "W: $path not file or symlink\n";
        }
        return $value;
}

sub conf {
        my $ip  = shift;
        my $name = shift;
        my ( $default, $value );
        if ( $#_ == 0 ) {
                $value = shift;
        } elsif ( $#_ == 1 && $_[0] eq 'default' ) {
                $default = $_[1]
        }

        my $path = ip_path $ip;
        mkdir $path unless -d $path;
        $path .= '/' . $name;

        if ( defined $value ) {
                mkbasedir  $path;
                write_file $path, $value;
                warn "update $path = $value";
        } elsif ( ! -e $path && defined $default ) {
                mkbasedir  $path;
                write_file $path, $default;
                warn "default $path = $default";
                $value = $default;
        } elsif ( -f $path ) {
                $value = read_file $path;
        } else {
                warn "# $name missing $path\n" if $debug;
        }
        return $value;
}

sub all_conf {
        my $ip = shift;
        my $path = ip_path $ip || return;
        my $conf;
        foreach my $file ( glob("$path/*") ) {
                my $name = $file;
                $name =~ s{^.+/([^/]+)$}{$1};
                $conf->{ $name } = read_file $file;
        }
        return $conf;
}
sub next_ip($) {
        my $mac = shift;
        $mac = format::mac($mac);

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

        my $prefix = $server::ip;
        $prefix =~ s{\.\d+$}{.};
        my $addr = $server::ip_from || die;
        my $ip = $prefix . $addr;

        while ( -e ip_path($ip) || $p->ping( $ip, 0.7 ) ) {
                $ip = $prefix . $addr++;
                die "all addresses allocated!" if $addr == $server::ip_to;
                warn "skip $ip\n";
        }

        warn "next_ip $ip\n";

        save_ip_mac( $ip, $mac );

        return $ip;
}

sub save_ip_mac {
        my ($ip,$mac) = @_;
        $mac = format::mac($mac);
        return if $mac eq '00:00:00:00:00:00';

        mkdir ip_path($ip) unless -e ip_path($ip);

        my $mac_path = mac_path($mac);
        unlink $mac_path if -l $mac_path;       # XXX audit?
        symlink ip_path($ip), $mac_path;
        write_file( ip_path($ip,'mac'), $mac );
}

sub ip_from_mac($) {
        my $mac = shift;
        $mac = format::mac($mac);

        my $mac_path = mac_path $mac;
        return unless -e $mac_path;

        my $ip;

        if ( -f $mac_path ) {
                $ip = read_file $mac_path;
                unlink $mac_path;
                symlink ip_path($ip), $mac_path;
                warn "I: upgrade to mac symlink $mac_path\n";
        } elsif ( -l $mac_path ) {
                $ip = conf_value $mac_path;
        } else {
                die "$mac_path not file or symlink";
        }

        return $ip;
}

sub mac_from_ip($) {
        my $ip = shift;
        conf_value ip_path($ip, 'mac');
}

sub change_ip($$) {
        my ($old, $new) = @_;
        return if $old eq $new;
        my $mac = mac_from_ip($old) || die "no mac for $old";
        rename ip_path($old), ip_path($new);
        unlink mac_path($mac);
        symlink ip_path($new), mac_path($mac);
        return $new;
}

sub all_ips {
        sort { ip::to_int($a) cmp ip::to_int($b) }
        map {
                my $ip = $_;
                $ip =~ s{^.+/ip/}{};
                $ip;
        } glob("$server::conf/ip/*") 
}

sub remove {
        my $ip = shift;
        unlink $_ foreach grep { -e $_ } ( glob "$server::conf/ip/$ip/*" );
        if ( my $mac = mac_from_ip $ip ) {
                unlink "$server::conf/mac/$mac";
        }
        rmdir "$server::conf/ip/$ip";
}

sub arp_mac_dev {
        my $arp = {
                map {
                        my @c = split(/\s+/,$_);
                        if ( $#c == 5 ) {
                                client::save_ip_mac( $c[0], $c[3] );
                                ( uc $c[3] => $c[5] )
                        } else {
                        }
                } read_file('/proc/net/arp')
        };

        warn "# arp ",dump( $arp );
        return $arp;
}

1;
1	dpavlin	156	package client;
2
3			use warnings;
4			use strict;
5			use autodie;
6
7			use File::Slurp;
8	dpavlin	168	use Net::Ping;
9	dpavlin	329	use Data::Dump qw/dump/;
10	dpavlin	219
11			use server;
12	dpavlin	208	use format;
13	dpavlin	322	use ip;
14	dpavlin	156
15	dpavlin	220	our $debug = $server::debug;
16
17	dpavlin	219	sub mkbasedir {
18			my $path = shift;
19			$path =~ s{(^.*)/[^/]+$}{$1};
20			mkdir $path unless -d $path;
21			return $path;
22			}
23
24	dpavlin	200	sub mac_path { $server::conf . '/mac/' . $_[0] }
25			sub ip_path { $server::conf . '/ip/' . join('/', @_) }
26	dpavlin	219	sub conf_value {
27			my $path = shift;
28			my $value;
29			if ( -l $path ) {
30			$value = readlink $path;
31			$value =~ s{.*/([^/]+)$}{$1};
32			} elsif ( -f $path ) {
33			$value = read_file $path;
34			} else {
35	dpavlin	244	warn "W: $path not file or symlink\n";
36	dpavlin	219	}
37			return $value;
38			}
39	dpavlin	200
40	dpavlin	156	sub conf {
41			my $ip = shift;
42			my $name = shift;
43			my ( $default, $value );
44			if ( $#_ == 0 ) {
45			$value = shift;
46			} elsif ( $#_ == 1 && $_[0] eq 'default' ) {
47			$default = $_[1]
48			}
49
50	dpavlin	200	my $path = ip_path $ip;
51	dpavlin	156	mkdir $path unless -d $path;
52			$path .= '/' . $name;
53
54			if ( defined $value ) {
55	dpavlin	219	mkbasedir $path;
56	dpavlin	156	write_file $path, $value;
57			warn "update $path = $value";
58			} elsif ( ! -e $path && defined $default ) {
59	dpavlin	219	mkbasedir $path;
60	dpavlin	156	write_file $path, $default;
61			warn "default $path = $default";
62			$value = $default;
63	dpavlin	219	} elsif ( -f $path ) {
64			$value = read_file $path;
65			} else {
66	dpavlin	220	warn "# $name missing $path\n" if $debug;
67	dpavlin	156	}
68			return $value;
69			}
70
71	dpavlin	305	sub all_conf {
72			my $ip = shift;
73			my $path = ip_path $ip \|\| return;
74			my $conf;
75			foreach my $file ( glob("$path/*") ) {
76			my $name = $file;
77			$name =~ s{^.+/([^/]+)$}{$1};
78			$conf->{ $name } = read_file $file;
79			}
80			return $conf;
81			}
82	dpavlin	200	sub next_ip($) {
83			my $mac = shift;
84	dpavlin	313	$mac = format::mac($mac);
85	dpavlin	168
86			my $p = Net::Ping->new;
87
88			my $prefix = $server::ip;
89			$prefix =~ s{\.\d+$}{.};
90			my $addr = $server::ip_from \|\| die;
91			my $ip = $prefix . $addr;
92
93	dpavlin	200	while ( -e ip_path($ip) \|\| $p->ping( $ip, 0.7 ) ) {
94	dpavlin	168	$ip = $prefix . $addr++;
95			die "all addresses allocated!" if $addr == $server::ip_to;
96			warn "skip $ip\n";
97			}
98
99			warn "next_ip $ip\n";
100	dpavlin	200
101	dpavlin	244	save_ip_mac( $ip, $mac );
102
103			return $ip;
104			}
105
106			sub save_ip_mac {
107			my ($ip,$mac) = @_;
108	dpavlin	313	$mac = format::mac($mac);
109	dpavlin	325	return if $mac eq '00:00:00:00:00:00';
110	dpavlin	244
111	dpavlin	254	mkdir ip_path($ip) unless -e ip_path($ip);
112	dpavlin	200
113	dpavlin	217	my $mac_path = mac_path($mac);
114	dpavlin	286	unlink $mac_path if -l $mac_path; # XXX audit?
115	dpavlin	217	symlink ip_path($ip), $mac_path;
116	dpavlin	323	write_file( ip_path($ip,'mac'), $mac );
117	dpavlin	168	}
118
119	dpavlin	200	sub ip_from_mac($) {
120	dpavlin	194	my $mac = shift;
121	dpavlin	313	$mac = format::mac($mac);
122	dpavlin	194
123	dpavlin	200	my $mac_path = mac_path $mac;
124	dpavlin	194	return unless -e $mac_path;
125
126			my $ip;
127
128			if ( -f $mac_path ) {
129			$ip = read_file $mac_path;
130			unlink $mac_path;
131	dpavlin	200	symlink ip_path($ip), $mac_path;
132	dpavlin	194	warn "I: upgrade to mac symlink $mac_path\n";
133			} elsif ( -l $mac_path ) {
134	dpavlin	219	$ip = conf_value $mac_path;
135	dpavlin	194	} else {
136			die "$mac_path not file or symlink";
137			}
138
139			return $ip;
140			}
141
142	dpavlin	200	sub mac_from_ip($) {
143			my $ip = shift;
144	dpavlin	219	conf_value ip_path($ip, 'mac');
145	dpavlin	200	}
146
147			sub change_ip($$) {
148			my ($old, $new) = @_;
149	dpavlin	323	return if $old eq $new;
150			my $mac = mac_from_ip($old) \|\| die "no mac for $old";
151	dpavlin	200	rename ip_path($old), ip_path($new);
152			unlink mac_path($mac);
153			symlink ip_path($new), mac_path($mac);
154	dpavlin	323	return $new;
155	dpavlin	200	}
156
157	dpavlin	322	sub all_ips {
158			sort { ip::to_int($a) cmp ip::to_int($b) }
159			map {
160			my $ip = $_;
161			$ip =~ s{^.+/ip/}{};
162			$ip;
163			} glob("$server::conf/ip/*")
164			}
165
166	dpavlin	323	sub remove {
167			my $ip = shift;
168			unlink $_ foreach grep { -e $_ } ( glob "$server::conf/ip/$ip/*" );
169			if ( my $mac = mac_from_ip $ip ) {
170			unlink "$server::conf/mac/$mac";
171			}
172			rmdir "$server::conf/ip/$ip";
173			}
174
175	dpavlin	329	sub arp_mac_dev {
176			my $arp = {
177			map {
178			my @c = split(/\s+/,$_);
179			if ( $#c == 5 ) {
180			client::save_ip_mac( $c[0], $c[3] );
181			( uc $c[3] => $c[5] )
182			} else {
183			}
184			} read_file('/proc/net/arp')
185			};
186
187			warn "# arp ",dump( $arp );
188			return $arp;
189			}
190
191	dpavlin	156	1;