Context Navigation

source: trunk/klask @ 78

Last change on this file since 78 was 78, checked in by g7moreau, 13 years ago
Last change. Limit arpwatch cache two 1.1 hour Some format thing
Property svn:executable set to ``* Property svn:keywords set to `Date Author Id Rev`
File size: 61.8 KB

Rev	Line
[2]	1	#!/usr/bin/perl -w
[32]	2	#
	3	# Copyright (C) 2005-2008 Gabriel Moreau.
	4	#
	5	# $Id: klask 78 2011-03-24 17:33:19Z g7moreau $
[2]	6
	7	use strict;
[3]	8	use warnings;
[63]	9	use version; our $VERSION = qv('0.5.5');
[2]	10
[63]	11	use Readonly;
[64]	12	use FileHandle;
[2]	13	use Net::SNMP;
[44]	14	#use YAML;
	15	use YAML::Syck;
[2]	16	use Net::Netmask;
	17	use Net::CIDR::Lite;
	18	use NetAddr::IP;
[69]	19	use Getopt::Long qw(GetOptions GetOptionsFromArray);;
[68]	20	use Socket;
[2]	21
[8]	22	# apt-get install snmp fping libnet-cidr-lite-perl libnet-netmask-perl libnet-snmp-perl libnetaddr-ip-perl libyaml-perl
[68]	23	# libcrypt-des-perl libcrypt-hcesha-perl libdigest-hmac-perl
[23]	24	# arping fping bind9-host arpwatch
[2]	25
[26]	26	my $KLASK_VAR = '/var/cache/klask';
[13]	27	my $KLASK_CFG_FILE = '/etc/klask.conf';
[28]	28	my $KLASK_DB_FILE = "$KLASK_VAR/klaskdb";
	29	my $KLASK_SW_FILE = "$KLASK_VAR/switchdb";
[2]	30
[26]	31	test_running_environnement();
	32
[44]	33	my $KLASK_CFG = YAML::Syck::LoadFile("$KLASK_CFG_FILE");
[2]	34
[63]	35	my %DEFAULT = %{ $KLASK_CFG->{default} };
	36	my @SWITCH = @{ $KLASK_CFG->{switch} };
[2]	37
[11]	38	my %switch_level = ();
[63]	39	my %SWITCH_DB = ();
[2]	40	LEVEL_OF_EACH_SWITCH:
[11]	41	for my $sw (@SWITCH){
	42	$switch_level{$sw->{hostname}} = $sw->{level} \|\| $DEFAULT{switch_level} \|\| 2;
[25]	43	$SWITCH_DB{$sw->{hostname}} = $sw;
[2]	44	}
[63]	45	@SWITCH = reverse sort { $switch_level{$a->{hostname}} <=> $switch_level{$b->{hostname}} } @{$KLASK_CFG->{switch}};
[2]	46
[15]	47	my %SWITCH_PORT_COUNT = ();
[2]	48
[11]	49	my %CMD_DB = (
[2]	50	help => \&cmd_help,
[36]	51	version => \&cmd_version,
[2]	52	exportdb => \&cmd_exportdb,
	53	updatedb => \&cmd_updatedb,
	54	searchdb => \&cmd_searchdb,
[4]	55	removedb => \&cmd_removedb,
[74]	56	cleandb => \&cmd_cleandb,
[2]	57	search => \&cmd_search,
	58	enable => \&cmd_enable,
	59	disable => \&cmd_disable,
	60	status => \&cmd_status,
[4]	61	updatesw => \&cmd_updatesw,
	62	exportsw => \&cmd_exportsw,
[2]	63	iplocation => \&cmd_iplocation,
[69]	64	'ip-free' => \&cmd_ip_free,
[35]	65	'search-mac-on-switch' => \&cmd_search_mac_on_switch,
[2]	66	);
	67
[63]	68	Readonly my %INTERNAL_PORT_MAP => (
[2]	69	0 => 'A',
	70	1 => 'B',
	71	2 => 'C',
	72	3 => 'D',
	73	4 => 'E',
	74	5 => 'F',
	75	6 => 'G',
	76	7 => 'H',
	77	);
[63]	78	Readonly my %INTERNAL_PORT_MAP_REV => reverse %INTERNAL_PORT_MAP;
[2]	79
[63]	80	Readonly my %SWITCH_KIND => (
[20]	81	J3299A => { model => 'HP224M', match => 'HP J3299A ProCurve Switch 224M' },
	82	J4120A => { model => 'HP1600M', match => 'HP J4120A ProCurve Switch 1600M' },
[27]	83	J9029A => { model => 'HP1800-8G', match => 'PROCURVE J9029A' },
[68]	84	J9449A => { model => 'HP1810-8G', match => 'HP ProCurve 1810G - 8 GE' },
[20]	85	J4093A => { model => 'HP2424M', match => 'HP J4093A ProCurve Switch 2424M' },
[78]	86	J9279A => { model => 'HP2510G-24', match => 'ProCurve J9279A Switch 2510G-24' },
[77]	87	J9280A => { model => 'HP2510G-48', match => 'ProCurve J9280A Switch 2510G-48' },
[20]	88	J4813A => { model => 'HP2524', match => 'HP J4813A ProCurve Switch 2524' },
[21]	89	J4900A => { model => 'HP2626A', match => 'HP J4900A ProCurve Switch 2626' },
[42]	90	J4900B => { model => 'HP2626B', match => 'J4900B.+?Switch 2626' },# ProCurve J4900B Switch 2626 # HP J4900B ProCurve Switch 2626
[30]	91	J4899B => { model => 'HP2650', match => 'ProCurve J4899B Switch 2650' },
[20]	92	J9021A => { model => 'HP2810-24G', match => 'ProCurve J9021A Switch 2810-24G' },
[41]	93	J9022A => { model => 'HP2810-48G', match => 'ProCurve J9022A Switch 2810-48G' },
[20]	94	J4903A => { model => 'HP2824', match => 'J4903A.+?Switch 2824,' },
	95	J4110A => { model => 'HP8000M', match => 'HP J4110A ProCurve Switch 8000M' },
	96	BS350T => { model => 'BS350T', match => 'BayStack 350T HW' },
[18]	97	);
[63]	98
	99	Readonly my %OID_NUMBER => (
[68]	100	sysDescription => '1.3.6.1.2.1.1.1.0',
	101	sysName => '1.3.6.1.2.1.1.5.0',
	102	sysContact => '1.3.6.1.2.1.1.4.0',
	103	sysLocation => '1.3.6.1.2.1.1.6.0',
[19]	104	);
[18]	105
[63]	106	Readonly my $RE_MAC_ADDRESS => qr{ [0-9,A-Z]{2} : [0-9,A-Z]{2} : [0-9,A-Z]{2} : [0-9,A-Z]{2} : [0-9,A-Z]{2} : [0-9,A-Z]{2} }xms;
	107	Readonly my $RE_IPv4_ADDRESS => qr{ [0-9]{1,3} \. [0-9]{1,3} \. [0-9]{1,3} \. [0-9]{1,3} }xms;
	108
	109
[2]	110	################
	111	# principal
	112	################
	113
[11]	114	my $cmd = shift @ARGV \|\| 'help';
	115	if (defined $CMD_DB{$cmd}) {
	116	$CMD_DB{$cmd}->(@ARGV);
[2]	117	}
	118	else {
[63]	119	print {*STDERR} "klask: command $cmd not found\n\n";
[11]	120	$CMD_DB{help}->();
[2]	121	exit 1;
	122	}
	123
	124	exit;
	125
[26]	126	sub test_running_environnement {
	127	die "Configuration file $KLASK_CFG_FILE does not exists. Klask need it !\n" if not -e "$KLASK_CFG_FILE";
	128	die "Var folder $KLASK_VAR does not exists. Klask need it !\n" if not -d "$KLASK_VAR";
[63]	129	return;
[26]	130	}
	131
[34]	132	sub test_switchdb_environnement {
	133	die "Switch database $KLASK_SW_FILE does not exists. Launch updatesw before this command !\n" if not -e "$KLASK_SW_FILE";
[63]	134	return;
[34]	135	}
	136
	137	sub test_maindb_environnement {
	138	die "Main database $KLASK_DB_FILE does not exists. Launch updatedb before this command !\n" if not -e "$KLASK_DB_FILE";
[63]	139	return;
[34]	140	}
	141
[2]	142	###
	143	# fast ping dont l'objectif est de remplir la table arp de la machine
	144	sub fastping {
[68]	145	# Launch this command without waiting...
	146	system "fping -c 1 @_ >/dev/null 2>&1 &";
[63]	147	return;
[2]	148	}
	149
[63]	150	sub shell_command {
	151	my $cmd = shift;
	152
[64]	153	my $fh = new FileHandle;
	154	my $result = '';
[63]	155	open $fh, q{-\|}, "$cmd" or die "Can't exec $cmd\n";
[64]	156	$result .= <$fh>;
[63]	157	close $fh;
	158	chomp $result;
	159	return $result;
	160	}
	161
[2]	162	###
	163	# donne l'@ ip, dns, arp en fonction du dns OU de l'ip
	164	sub resolve_ip_arp_host {
	165	my $param_ip_or_host = shift;
[63]	166	my $interface = shift \|\| q{*};
	167	my $type = shift \|\| q{fast};
[2]	168
	169	my %ret = (
	170	hostname_fq => 'unknow',
	171	ipv4_address => '0.0.0.0',
	172	mac_address => 'unknow',
	173	);
	174
	175	# my $cmdarping = `arping -c 1 -w 1 -rR $param 2>/dev/null`;
[68]	176	# if ( not $param_ip_or_host =~ m/^\d+ \. \d+ \. \d+ \. \d+$/xms ) {
	177	# $param_ip_or_host =~ s/ \. .* //xms;
	178	# }
[2]	179
[68]	180	#my $dns_resolver = Net::DNS::Resolver->new;
	181	#my $dns_answer = $dns_resolver->query($param_ip_or_host);
	182	#if ($dns_answer) {
	183	# $ret{ipv4_address} = $dns_answer->address;
	184	# }
	185
	186	# perl -MSocket -E 'say inet_ntoa(scalar gethostbyname("tech7meylan.hmg.inpg.fr"))'
	187	my $packed_ip = scalar gethostbyname($param_ip_or_host);
	188	return %ret if not defined $packed_ip;
	189	$ret{ipv4_address} = inet_ntoa($packed_ip);
	190
	191	# perl -MSocket -E 'say scalar gethostbyaddr(inet_aton("194.254.66.240"), AF_INET)'
	192	my $hostname_fq = scalar gethostbyaddr($packed_ip, AF_INET);
	193	# return %ret if not defined $hostname_fq;
	194	$ret{hostname_fq} = $hostname_fq if defined $hostname_fq;
	195
	196	#print "DEBUG : $param_ip_or_host -- $ret{ipv4_address} -- $hostname_fq \n";
	197
[2]	198	# controler que arpwatch tourne !
	199	# resultat de la commande arpwatch
	200	# /var/lib/arpwatch/arp.dat
	201	# 0:13:d3:e1:92:d0 192.168.24.109 1163681980 theo8sv109
[44]	202	# my $cmd = "grep -e '".'\b'."$param_ip_or_host".'\b'."' /var/lib/arpwatch/arp.dat \| sort +2rn \| head -1";
	203	# my $cmd = "grep -he '".'\b'."$param_ip_or_host".'\b'."' /var/lib/arpwatch/*.dat \| sort +2rn \| head -1";
[68]	204
	205	### BOGUE ICI
	206	### FAIRE LE GREP SUR L'IP !
	207
	208	# my $cmd = q{grep -he '\b} . $param_ip_or_host . q{\b' } . "/var/lib/arpwatch/$interface.dat \| sort -rn -k 3,3 \| head -1";
	209	my $cmd = q{grep -he '\b} . $ret{ipv4_address} . q{\b' } . "/var/lib/arpwatch/$interface.dat \| sort -rn -k 3,3 \| head -1";
[62]	210	my $cmd_arpwatch = shell_command $cmd;
	211	my ($arp, $ip, $timestamp, $host) = split m/ \s+ /xms, $cmd_arpwatch;
[44]	212
[68]	213	# $ret{ipv4_address} = $ip if $ip;
[2]	214	$ret{mac_address} = $arp if $arp;
	215	$ret{timestamp} = $timestamp if $timestamp;
	216
[63]	217	my $nowtimestamp = time;
[3]	218
[78]	219	if ( $type eq 'fast' and ( not defined $timestamp or $timestamp < ( $nowtimestamp - 1.1 * 3600 ) ) ) {
[3]	220	$ret{mac_address} = 'unknow';
	221	return %ret;
	222	}
	223
[63]	224	# resultat de la commande arp
[2]	225	# tech7meylan.hmg.inpg.fr (194.254.66.240) at 00:14:22:45:28:A9 [ether] on eth0
[44]	226	# sw2-batF0-legi.hmg.priv (192.168.22.112) at 00:30:c1:76:9c:01 [ether] on eth0.37
[63]	227	my $cmd_arp = shell_command "arp -a $param_ip_or_host";
	228	if ( $cmd_arp =~ m{ (\S*) \s \( ( $RE_IPv4_ADDRESS ) \) \s at \s ( $RE_MAC_ADDRESS ) }xms ) {
	229	( $ret{hostname_fq}, $ret{ipv4_address}, $ret{mac_address} ) = ($1, $2, $3);
	230	}
[2]	231
[63]	232	# resultat de la commande host si le parametre est ip
	233	# 250.66.254.194.in-addr.arpa domain name pointer legihp2100.hmg.inpg.fr.
[68]	234	# my $cmd_host = shell_command "host $param_ip_or_host";
	235	# if ( $cmd_host =~ m/domain \s name \s pointer \s (\S+) \.$/xms ) {
	236	# $ret{hostname_fq} = $1;
	237	# }
[2]	238
[63]	239	# resultat de la commande host si parametre est hostname
	240	# tech7meylan.hmg.inpg.fr has address 194.254.66.240
[68]	241	# if ( $cmd_host =~ m/(\S*) \s has \s address \s ( $RE_IPv4_ADDRESS )$/xms ) {
	242	# ( $ret{hostname_fq}, $ret{ipv4_address} ) = ($1, $2);
	243	# }
[2]	244
[65]	245	# Connerie !
	246	# Inverse les IP !!
	247	# if ( $cmd_host =~ m/ \b ( $RE_IPv4_ADDRESS ) \. in-addr \. arpa \s/xms ) {
	248	# $ret{ipv4_address} = $1;
	249	# }
[63]	250	#$ret{hostname_fq} = $param_ip_or_host if not defined $1 and $ret{hostname_fq} eq 'unknow';
[2]	251
[63]	252	if ($ret{mac_address} ne 'unknow') {
[2]	253	my @paquets = ();
[63]	254	foreach ( split m/ : /xms, $ret{mac_address} ) {
	255	my @chars = split m//xms, uc "00$_";
[2]	256	push @paquets, "$chars[-2]$chars[-1]";
	257	}
[63]	258	$ret{mac_address} = join q{:}, @paquets;
[2]	259	}
	260
	261	return %ret;
	262	}
	263
[20]	264	# Find Surname of a switch
	265	sub get_switch_model {
[22]	266	my $sw_snmp_description = shift \|\| 'unknow';
[63]	267
[20]	268	for my $sw_kind (keys %SWITCH_KIND) {
[64]	269	next if not $sw_snmp_description =~ m/$SWITCH_KIND{$sw_kind}->{match}/ms; # option xms break search, why ?
[63]	270
[20]	271	return $SWITCH_KIND{$sw_kind}->{model};
	272	}
[63]	273
[22]	274	return $sw_snmp_description;
[20]	275	}
	276
[2]	277	###
	278	# va rechercher le nom des switchs pour savoir qui est qui
[4]	279	sub init_switch_names {
[2]	280	my $verbose = shift;
[63]	281
[14]	282	printf "%-25s %-25s %s\n",'Switch','Description','Type';
	283	print "-------------------------------------------------------------------------\n" if $verbose;
[2]	284
	285	INIT_EACH_SWITCH:
[11]	286	for my $sw (@SWITCH) {
[3]	287	my %session = ( -hostname => $sw->{hostname} );
	288	$session{-version} = $sw->{version} \|\| 1;
[11]	289	$session{-port} = $sw->{snmpport} \|\| $DEFAULT{snmpport} \|\| 161;
[63]	290	if (exists $sw->{version} and $sw->{version} eq '3') {
[3]	291	$session{-username} = $sw->{username} \|\| 'snmpadmin';
	292	}
	293	else {
[11]	294	$session{-community} = $sw->{community} \|\| $DEFAULT{community} \|\| 'public';
[3]	295	}
	296
	297	$sw->{local_session} = \%session;
	298
	299	my ($session, $error) = Net::SNMP->session( %{$sw->{local_session}} );
[14]	300	print "$error \n" if $error;
	301
[2]	302	my $result = $session->get_request(
[18]	303	-varbindlist => [
[63]	304	$OID_NUMBER{sysDescription},
[18]	305	$OID_NUMBER{sysName},
	306	$OID_NUMBER{sysContact},
	307	$OID_NUMBER{sysLocation},
	308	]
[2]	309	);
[18]	310	$sw->{description} = $result->{$OID_NUMBER{sysName}} \|\| $sw->{hostname};
[63]	311	$sw->{model} = get_switch_model( $result->{$OID_NUMBER{sysDescription}});
[3]	312	#$sw->{location} = $result->{"1.3.6.1.2.1.1.6.0"} \|\| $sw->{hostname};
	313	#$sw->{contact} = $result->{"1.3.6.1.2.1.1.4.0"} \|\| $sw->{hostname};
[2]	314	$session->close;
[22]	315
[63]	316	# Ligne à virer car on récupère maintenant le modèle du switch
	317	my ($desc, $type) = split m/ : /xms, $sw->{description}, 2;
[20]	318	printf "%-25s 0--------->>>> %-25s %s\n", $sw->{hostname}, $desc, $sw->{model} if $verbose;
[2]	319	}
	320
	321	print "\n" if $verbose;
[63]	322	return;
[2]	323	}
	324
	325	###
	326	# convertit l'hexa (uniquement 2 chiffres) en decimal
[4]	327	sub hex_to_dec {
[2]	328	#00:0F:1F:43:E4:2B
[63]	329	my $car = '00' . uc shift;
[2]	330
[4]	331	return '00' if $car eq '00UNKNOW';
[2]	332	my %table = (
[62]	333	'0'=>'0', '1'=>'1', '2'=>'2', '3'=>'3', '4'=>'4',
	334	'5'=>'5', '6'=>'6', '7'=>'7', '8'=>'8', '9'=>'9',
[63]	335	'A'=>'10', 'B'=>'11', 'C'=>'12', 'D'=>'13', 'E'=>'14', 'F'=>'15',
[2]	336	);
[63]	337	my @chars = split m//xms, $car;
[2]	338	return $table{$chars[-2]}*16 + $table{$chars[-1]};
	339	}
	340
	341	###
	342	# convertit l'@ arp en decimal
[4]	343	sub arp_hex_to_dec {
[2]	344	#00:0F:1F:43:E4:2B
	345	my $arp = shift;
	346
[63]	347	my @paquets = split m/ : /xms, $arp;
	348	my $return = q{};
[2]	349	foreach(@paquets) {
[63]	350	$return .= q{.} . hex_to_dec($_);
[2]	351	}
	352	return $return;
	353	}
	354
	355	###
	356	# va rechercher le port et le switch sur lequel est la machine
	357	sub find_switch_port {
[63]	358	my $arp = shift;
	359	my $switch_proposal = shift \|\| q{};
	360
[2]	361	my %ret;
[63]	362	$ret{switch_description} = 'unknow';
	363	$ret{switch_port} = '0';
[2]	364
	365	return %ret if $arp eq 'unknow';;
	366
[22]	367	my @switch_search = @SWITCH;
[63]	368	if ($switch_proposal ne q{}) {
[11]	369	for my $sw (@SWITCH) {
[2]	370	next if $sw->{hostname} ne $switch_proposal;
[22]	371	unshift @switch_search, $sw;
[2]	372	last;
	373	}
	374	}
	375
[63]	376	my $research = '1.3.6.1.2.1.17.4.3.1.2' . arp_hex_to_dec($arp);
	377
[2]	378	LOOP_ON_SWITCH:
[22]	379	for my $sw (@switch_search) {
[3]	380	my ($session, $error) = Net::SNMP->session( %{$sw->{local_session}} );
[22]	381	print "$error \n" if $error;
	382
[2]	383	my $result = $session->get_request(
	384	-varbindlist => [$research]
	385	);
[63]	386	if (not defined $result or $result->{$research} eq 'noSuchInstance') {
[2]	387	$session->close;
	388	next LOOP_ON_SWITCH;
	389	}
	390
	391	my $swport = $result->{$research};
	392	$session->close;
	393
	394	# IMPORTANT !!
[63]	395	# ceci empeche la detection sur certains port ...
[2]	396	# en effet les switch sont relies entre eux par un cable reseau et du coup
	397	# tous les arp de toutes les machines sont presentes sur ces ports (ceux choisis ici sont les miens)
	398	# cette partie est a ameliore, voir a configurer dans l'entete
	399	# 21->24 45->48
	400	# my $flag = 0;
	401	SWITCH_PORT_IGNORE:
	402	foreach my $p (@{$sw->{portignore}}) {
[22]	403	next SWITCH_PORT_IGNORE if $swport ne get_numerical_port($sw->{model},$p);
[2]	404	# $flag = 1;
	405	next LOOP_ON_SWITCH;
	406	}
	407	# if ($flag == 0) {
	408	$ret{switch_hostname} = $sw->{hostname};
	409	$ret{switch_description} = $sw->{description};
[22]	410	$ret{switch_port} = get_human_readable_port($sw->{model}, $swport); # $swport;
[63]	411
[2]	412	last LOOP_ON_SWITCH;
	413	# }
	414	# }
	415	# $session->close;
	416	}
	417	return %ret;
	418	}
	419
	420	###
	421	# va rechercher les port et les switch sur lequel est la machine
	422	sub find_all_switch_port {
	423	my $arp = shift;
	424
	425	my $ret = {};
	426
	427	return $ret if $arp eq 'unknow';
	428
[11]	429	for my $sw (@SWITCH) {
[15]	430	$SWITCH_PORT_COUNT{$sw->{hostname}} = {} if not exists $SWITCH_PORT_COUNT{$sw->{hostname}};
[2]	431	}
	432
[63]	433	my $research = '1.3.6.1.2.1.17.4.3.1.2' . arp_hex_to_dec($arp);
[2]	434	LOOP_ON_ALL_SWITCH:
[11]	435	for my $sw (@SWITCH) {
[3]	436	my ($session, $error) = Net::SNMP->session( %{$sw->{local_session}} );
[13]	437	print "$error \n" if $error;
	438
[2]	439	my $result = $session->get_request(
	440	-varbindlist => [$research]
	441	);
[13]	442
[63]	443	if(defined $result and $result->{$research} ne 'noSuchInstance'){
[2]	444	my $swport = $result->{$research};
	445
[68]	446	#print "DEBUG $arp $swport -- $sw->{hostname} \n";
	447	if ( $sw->{hostname} eq 'sw10-batE1-3s.hmg.priv' and $swport == 19 ) { $swport = 20; print "DEBUG $swport -- $sw->{hostname} \n";}
	448	if ( $sw->{hostname} eq 'sw8-batE1-3s.hmg.priv' and $swport == 23 ) { $swport = 24; print "DEBUG $swport -- $sw->{hostname} \n";}
	449	# if ( $sw->{hostname} eq 'sw10-batE1-3s.hmg.priv' ) { print "DEBUG $swport -- $sw->{hostname} \n";}
	450	# if ( $sw->{hostname} eq 'sw8-batE1-3s.hmg.priv' ) { print "DEBUG $swport -- $sw->{hostname} \n";}
	451
[2]	452	$ret->{$sw->{hostname}} = {};
	453	$ret->{$sw->{hostname}}{hostname} = $sw->{hostname};
	454	$ret->{$sw->{hostname}}{description} = $sw->{description};
[22]	455	$ret->{$sw->{hostname}}{port} = get_human_readable_port($sw->{model}, $swport);
[2]	456
[15]	457	$SWITCH_PORT_COUNT{$sw->{hostname}}->{$swport}++;
[2]	458	}
	459
	460	$session->close;
	461	}
	462	return $ret;
	463	}
	464
	465	sub get_list_network {
	466
[12]	467	return keys %{$KLASK_CFG->{network}};
[2]	468	}
	469
	470	sub get_current_interface {
	471	my $network = shift;
	472
[12]	473	return $KLASK_CFG->{network}{$network}{interface};
[2]	474	}
[63]	475
[2]	476	###
	477	# liste l'ensemble des adresses ip d'un réseau
	478	sub get_list_ip {
	479	my @network = @_;
	480
	481	my $cidrlist = Net::CIDR::Lite->new;
	482
	483	for my $net (@network) {
[12]	484	my @line = @{$KLASK_CFG->{network}{$net}{'ip-subnet'}};
[2]	485	for my $cmd (@line) {
[63]	486	for my $method (keys %{$cmd}){
[2]	487	$cidrlist->add_any($cmd->{$method}) if $method eq 'add';
	488	}
	489	}
	490	}
	491
[4]	492	my @res = ();
[2]	493
	494	for my $cidr ($cidrlist->list()) {
	495	my $net = new NetAddr::IP $cidr;
[63]	496	for my $ip (@{$net}) {
	497	$ip =~ s{ /32 }{}xms;
[2]	498	push @res, $ip;
	499	}
	500	}
	501
	502	return @res;
	503	}
	504
[9]	505	# liste l'ensemble des routeurs du réseau
	506	sub get_list_main_router {
	507	my @network = @_;
	508
	509	my @res = ();
	510
	511	for my $net (@network) {
[12]	512	push @res, $KLASK_CFG->{network}{$net}{'main-router'};
[9]	513	}
	514
	515	return @res;
	516	}
	517
[2]	518	sub get_human_readable_port {
[22]	519	my $sw_model = shift;
	520	my $sw_port = shift;
[63]	521
[64]	522	if ($sw_model eq 'HP8000M') {
[63]	523
[64]	524	my $reste = (($sw_port - 1) % 8) + 1;
	525	my $major = int (($sw_port - 1) / 8);
	526	return "$INTERNAL_PORT_MAP{$major}$reste";
	527	}
[2]	528
[64]	529	if ($sw_model eq 'HP2424M') {
	530	if ($sw_port > 24) {
	531
	532	my $reste = $sw_port - 24;
	533	return "A$reste";
	534	}
	535	}
	536
	537	if ($sw_model eq 'HP1600M') {
	538	if ($sw_port > 16) {
	539
	540	my $reste = $sw_port - 16;
	541	return "A$reste";
	542	}
	543	}
	544
	545	return $sw_port;
[2]	546	}
	547
	548	sub get_numerical_port {
[22]	549	my $sw_model = shift;
	550	my $sw_port = shift;
[63]	551
[64]	552	if ($sw_model eq 'HP8000M') {
[2]	553
[64]	554	my $letter = substr $sw_port, 0, 1;
	555	my $reste = substr $sw_port, 1;
[63]	556
[64]	557	return $INTERNAL_PORT_MAP_REV{$letter} * 8 + $reste;
	558	}
[63]	559
[64]	560	if ($sw_model eq 'HP2424M') {
	561	if ($sw_port =~ m/^A/xms ) {
[63]	562
[64]	563	my $reste = substr $sw_port, 1;
	564
	565	return 24 + $reste;
	566	}
	567	}
	568
	569	if ($sw_model eq 'HP1600M') {
	570	if ($sw_port =~ m/^A/xms ) {
	571
	572	my $reste = substr $sw_port, 1;
	573
	574	return 16 + $reste;
	575	}
	576	}
	577
	578	return $sw_port;
[2]	579	}
	580
	581	################
	582	# Les commandes
	583	################
	584
	585	sub cmd_help {
	586
[63]	587	print <<'END';
[2]	588	klask - ports manager and finder for switch
	589
	590	klask updatedb
[69]	591	klask exportdb --format [txt\|html]
[76]	592	klask removedb computer*
[75]	593	klask cleandb --day number_of_day --verbose
[2]	594
[45]	595	klask updatesw
[69]	596	klask exportsw --format [txt\|dot]
[45]	597
[2]	598	klask searchdb computer
	599	klask search computer
[68]	600	klask search-mac-on-switch switch mac_addr
[2]	601
[76]	602	klask ip-free --day number_of_day --format [txt\|html] [vlan_name]
[69]	603
[2]	604	klask enable switch port
	605	klask disable switch port
	606	klask status switch port
	607	END
[63]	608	return;
[2]	609	}
	610
[36]	611	sub cmd_version {
	612
[63]	613	print <<'END';
[36]	614	Klask - ports manager and finder for switch
	615	Copyright (C) 2005-2008 Gabriel Moreau
	616
	617	END
[37]	618	print ' $Rev: 78 $'."\n";
	619	print ' $Date: 2011-03-24 17:33:19 +0000 (Thu, 24 Mar 2011) $'."\n";
	620	print ' $Id: klask 78 2011-03-24 17:33:19Z g7moreau $'."\n";
[63]	621	return;
[36]	622	}
	623
[2]	624	sub cmd_search {
	625	my @computer = @_;
[63]	626
[4]	627	init_switch_names(); #nomme les switchs
[2]	628	fastping(@computer);
	629	for my $clientname (@computer) {
	630	my %resol_arp = resolve_ip_arp_host($clientname); #resolution arp
	631	my %where = find_switch_port($resol_arp{mac_address}); #retrouve l'emplacement
[63]	632	printf '%-22s %2i %-30s %-15s %18s', $where{switch_description}, $where{switch_port}, $resol_arp{hostname_fq}, $resol_arp{ipv4_address}, $resol_arp{mac_address}."\n"
[2]	633	unless $where{switch_description} eq 'unknow' and $resol_arp{hostname_fq} eq 'unknow' and $resol_arp{mac_address} eq 'unknow';
	634	}
[63]	635	return;
[2]	636	}
	637
	638	sub cmd_searchdb {
	639	my @computer = @_;
	640
	641	fastping(@computer);
[44]	642	my $computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE");
[63]	643
[2]	644	LOOP_ON_COMPUTER:
	645	for my $clientname (@computer) {
	646	my %resol_arp = resolve_ip_arp_host($clientname); #resolution arp
	647	my $ip = $resol_arp{ipv4_address};
[63]	648
[2]	649	next LOOP_ON_COMPUTER unless exists $computerdb->{$ip};
[63]	650
	651	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime $computerdb->{$ip}{timestamp};
[2]	652	$year += 1900;
	653	$mon++;
[63]	654	my $date = sprintf '%04i-%02i-%02i %02i:%02i', $year, $mon, $mday, $hour, $min;
[2]	655
	656	printf "%-22s %2s %-30s %-15s %-18s %s\n",
	657	$computerdb->{$ip}{switch_name},
	658	$computerdb->{$ip}{switch_port},
	659	$computerdb->{$ip}{hostname_fq},
	660	$ip,
	661	$computerdb->{$ip}{mac_address},
	662	$date;
	663	}
[63]	664	return;
[2]	665	}
	666
	667	sub cmd_updatedb {
	668	my @network = @_;
	669	@network = get_list_network() if not @network;
	670
[34]	671	test_switchdb_environnement();
	672
	673	my $computerdb = {};
[44]	674	$computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE") if -e "$KLASK_DB_FILE";
[2]	675	my $timestamp = time;
[22]	676
[2]	677	my %computer_not_detected = ();
	678	my $timestamp_last_week = $timestamp - (3600 * 24 * 7);
	679
	680	my $number_of_computer = get_list_ip(@network); # + 1;
[63]	681	my $size_of_database = keys %{$computerdb};
[31]	682	$size_of_database = 1 if $size_of_database == 0;
[2]	683	my $i = 0;
	684	my $detected_computer = 0;
[22]	685
[4]	686	init_switch_names('yes'); #nomme les switchs
[2]	687
[22]	688	{ # Remplis le champs portignore des ports d'inter-connection pour chaque switch
[44]	689	my $switch_connection = YAML::Syck::LoadFile("$KLASK_SW_FILE");
[22]	690	my %db_switch_output_port = %{$switch_connection->{output_port}};
	691	my %db_switch_connected_on_port = %{$switch_connection->{connected_on_port}};
	692	my %db_switch_chained_port = ();
[63]	693	for my $swport (keys %db_switch_connected_on_port) {
	694	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[22]	695	$db_switch_chained_port{$sw_connect} .= "$port_connect:";
	696	}
	697	for my $sw (@SWITCH){
	698	push @{$sw->{portignore}}, $db_switch_output_port{$sw->{hostname}} if exists $db_switch_output_port{$sw->{hostname}};
	699	if ( exists $db_switch_chained_port{$sw->{hostname}} ) {
	700	chop $db_switch_chained_port{$sw->{hostname}};
[63]	701	push @{$sw->{portignore}}, split m/ : /xms, $db_switch_chained_port{$sw->{hostname}};
[22]	702	}
	703	# print "$sw->{hostname} ++ @{$sw->{portignore}}\n";
	704	}
	705	}
	706
[2]	707	my %router_mac_ip = ();
	708	DETECT_ALL_ROUTER:
[9]	709	# for my $one_router ('194.254.66.254') {
	710	for my $one_router ( get_list_main_router(@network) ) {
[2]	711	my %resol_arp = resolve_ip_arp_host($one_router);
	712	$router_mac_ip{ $resol_arp{mac_address} } = $resol_arp{ipv4_address};
	713	}
	714
	715	ALL_NETWORK:
	716	for my $net (@network) {
	717
	718	my @computer = get_list_ip($net);
	719	my $current_interface = get_current_interface($net);
	720
	721	fastping(@computer);
	722
	723	LOOP_ON_COMPUTER:
	724	for my $one_computer (@computer) {
	725	$i++;
[49]	726
[63]	727	my $total_percent = int (($i*100)/$number_of_computer);
	728
[2]	729	my $localtime = time - $timestamp;
[63]	730	my ($sec,$min) = localtime $localtime;
[2]	731
	732	my $time_elapse = 0;
	733	$time_elapse = $localtime * ( 100 - $total_percent) / $total_percent if $total_percent != 0;
[63]	734	my ($sec_elapse,$min_elapse) = localtime $time_elapse;
[2]	735
	736	printf "\rComputer scanned: %4i/%i (%2i%%)", $i, $number_of_computer, $total_percent;
	737	# printf ", Computer detected: %4i/%i (%2i%%)", $detected_computer, $size_of_database, int(($detected_computer*100)/$size_of_database);
[63]	738	printf ', detected: %4i/%i (%2i%%)', $detected_computer, $size_of_database, int(($detected_computer*100)/$size_of_database);
	739	printf ' [Time: %02i:%02i / %02i:%02i]', int($localtime/60), $localtime % 60, int($time_elapse/60), $time_elapse % 60;
	740	# printf ' [%02i:%02i/%02i:%02i]', int($localtime/60), $localtime % 60, int($time_elapse/60), $time_elapse % 60;
	741	printf ' %-14s', $one_computer;
[2]	742
	743	my %resol_arp = resolve_ip_arp_host($one_computer,$current_interface);
[63]	744
[9]	745	# do not search on router connection (why ?)
[2]	746	if ( exists $router_mac_ip{$resol_arp{mac_address}}) {
	747	$computer_not_detected{$one_computer} = $current_interface;
	748	next LOOP_ON_COMPUTER;
	749	}
	750
[9]	751	# do not search on switch inter-connection
[2]	752	if (exists $switch_level{$resol_arp{hostname_fq}}) {
	753	$computer_not_detected{$one_computer} = $current_interface;
	754	next LOOP_ON_COMPUTER;
	755	}
	756
[63]	757	my $switch_proposal = q{};
[2]	758	if (exists $computerdb->{$resol_arp{ipv4_address}} and exists $computerdb->{$resol_arp{ipv4_address}}{switch_hostname}) {
	759	$switch_proposal = $computerdb->{$resol_arp{ipv4_address}}{switch_hostname};
	760	}
	761
[3]	762	# do not have a mac address
	763	if ($resol_arp{mac_address} eq 'unknow' or (exists $resol_arp{timestamps} and $resol_arp{timestamps} < ($timestamp - 3 * 3600))) {
	764	$computer_not_detected{$one_computer} = $current_interface;
	765	next LOOP_ON_COMPUTER;
	766	}
	767
[2]	768	my %where = find_switch_port($resol_arp{mac_address},$switch_proposal);
	769
	770	#192.168.24.156:
	771	# arp: 00:0B:DB:D5:F6:65
	772	# hostname: pcroyon.hmg.priv
	773	# port: 5
	774	# switch: sw-batH-legi:hp2524
	775	# timestamp: 1164355525
	776
	777	# do not have a mac address
[3]	778	# if ($resol_arp{mac_address} eq 'unknow') {
	779	# $computer_not_detected{$one_computer} = $current_interface;
	780	# next LOOP_ON_COMPUTER;
	781	# }
[2]	782
	783	# detected on a switch
	784	if ($where{switch_description} ne 'unknow') {
	785	$detected_computer++;
	786	$computerdb->{$resol_arp{ipv4_address}} = {
	787	hostname_fq => $resol_arp{hostname_fq},
	788	mac_address => $resol_arp{mac_address},
	789	switch_hostname => $where{switch_hostname},
	790	switch_description => $where{switch_description},
	791	switch_port => $where{switch_port},
	792	timestamp => $timestamp,
[45]	793	network => $net,
[2]	794	};
	795	next LOOP_ON_COMPUTER;
	796	}
	797
	798	# new in the database but where it is ?
	799	if (not exists $computerdb->{$resol_arp{ipv4_address}}) {
	800	$detected_computer++;
	801	$computerdb->{$resol_arp{ipv4_address}} = {
	802	hostname_fq => $resol_arp{hostname_fq},
	803	mac_address => $resol_arp{mac_address},
	804	switch_hostname => $where{switch_hostname},
	805	switch_description => $where{switch_description},
	806	switch_port => $where{switch_port},
	807	timestamp => $resol_arp{timestamp},
[45]	808	network => $net,
[2]	809	};
	810	}
	811
	812	# mise a jour du nom de la machine si modification dans le dns
	813	$computerdb->{$resol_arp{ipv4_address}}{hostname_fq} = $resol_arp{hostname_fq};
[63]	814
[2]	815	# mise à jour de la date de détection si détection plus récente par arpwatch
	816	$computerdb->{$resol_arp{ipv4_address}}{timestamp} = $resol_arp{timestamp} if exists $resol_arp{timestamp} and $computerdb->{$resol_arp{ipv4_address}}{timestamp} < $resol_arp{timestamp};
	817
	818	# relance un arping sur la machine si celle-ci n'a pas été détectée depuis plus d'une semaine
	819	# push @computer_not_detected, $resol_arp{ipv4_address} if $computerdb->{$resol_arp{ipv4_address}}{timestamp} < $timestamp_last_week;
	820	$computer_not_detected{$resol_arp{ipv4_address}} = $current_interface if $computerdb->{$resol_arp{ipv4_address}}{timestamp} < $timestamp_last_week;
[63]	821
[2]	822	}
	823	}
	824
	825	# final end of line at the end of the loop
	826	printf "\n";
	827
[13]	828	my $dirdb = $KLASK_DB_FILE;
[63]	829	$dirdb =~ s{ / [^/]* $}{}xms;
[2]	830	mkdir "$dirdb", 0755 unless -d "$dirdb";
[44]	831	YAML::Syck::DumpFile("$KLASK_DB_FILE", $computerdb);
[2]	832
	833	for my $one_computer (keys %computer_not_detected) {
	834	my $interface = $computer_not_detected{$one_computer};
[16]	835	system "arping -c 1 -w 1 -rR -i $interface $one_computer &>/dev/null";
[2]	836	# print "arping -c 1 -w 1 -rR -i $interface $one_computer 2>/dev/null\n";
	837	}
[63]	838	return;
[2]	839	}
	840
	841	sub cmd_removedb {
	842	my @computer = @_;
[34]	843
	844	test_maindb_environnement();
	845
[44]	846	my $computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE");
[2]	847
	848	LOOP_ON_COMPUTER:
	849	for my $one_computer (@computer) {
	850
[66]	851	if ( $one_computer =~ m/^ $RE_IPv4_ADDRESS $/xms
	852	and exists $computerdb->{$one_computer} ) {
	853	delete $computerdb->{$one_computer};
	854	next;
	855	}
	856
[2]	857	my %resol_arp = resolve_ip_arp_host($one_computer);
	858
	859	delete $computerdb->{$resol_arp{ipv4_address}} if exists $computerdb->{$resol_arp{ipv4_address}};
	860	}
	861
[13]	862	my $dirdb = $KLASK_DB_FILE;
[63]	863	$dirdb =~ s{ / [^/]* $}{}xms;
[2]	864	mkdir "$dirdb", 0755 unless -d "$dirdb";
[44]	865	YAML::Syck::DumpFile("$KLASK_DB_FILE", $computerdb);
[63]	866	return;
[2]	867	}
	868
[74]	869	sub cmd_cleandb {
	870	my @options = @_;
	871
	872	my $days_to_clean = 15;
	873	my $verbose;
	874	my $database_has_changed;
	875
	876	my $ret = GetOptionsFromArray(\@options,
	877	'day\|d=i' => \$days_to_clean,
	878	'verbose\|v' => \$verbose,
	879	);
	880
	881	my @vlan_name = get_list_network();
	882
	883	my $computerdb = {};
	884	$computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE") if -e "$KLASK_DB_FILE";
	885	my $timestamp = time;
	886
	887	my $timestamp_barrier = 3600 * 24 * $days_to_clean;
	888
	889	ALL_VLAN:
	890	for my $vlan (@vlan_name) {
	891
	892	my @ip_list = get_list_ip($vlan);
	893	my %mactimedb = ();
	894
	895	LOOP_ON_IP_ADDRESS:
	896	for my $ip (@ip_list) {
	897
	898	next LOOP_ON_IP_ADDRESS if
	899	not exists $computerdb->{$ip};
	900
	901	#&& $computerdb->{$ip}{timestamp} > $timestamp_barrier;
	902	my $ip_timestamp = $computerdb->{$ip}{timestamp};
	903	my $ip_mac = $computerdb->{$ip}{mac_address};
	904
	905	$mactimedb{$ip_mac} \|\|= [ $ip, $ip_timestamp ];
	906
	907	if ( $mactimedb{$ip_mac}->[1] - $ip_timestamp > $timestamp_barrier ) {
	908	print "remove ip $ip\n" if $verbose;
	909	delete $computerdb->{$ip};
	910	$database_has_changed++;
	911	}
	912
	913	if ( $ip_timestamp - $mactimedb{$ip_mac}->[1] > $timestamp_barrier ) {
	914	print "remove ip ".$mactimedb{$ip_mac}->[0]."\n" if $verbose;
	915	delete $computerdb->{$mactimedb{$ip_mac}->[0]};
	916	$database_has_changed++;
	917	}
	918
	919	if ( $ip_timestamp > $mactimedb{$ip_mac}->[1]) {
	920	$mactimedb{$ip_mac} = [ $ip, $ip_timestamp ];
	921	}
	922	}
	923	}
	924
	925	if ( $database_has_changed ) {
	926	my $dirdb = $KLASK_DB_FILE;
	927	$dirdb =~ s{ / [^/]* $}{}xms;
	928	mkdir "$dirdb", 0755 unless -d "$dirdb";
	929	YAML::Syck::DumpFile("$KLASK_DB_FILE", $computerdb);
	930	}
	931	return;
	932	}
	933
[2]	934	sub cmd_exportdb {
[45]	935	my @ARGV = @_;
	936
	937	my $format = 'txt';
	938
	939	my $ret = GetOptions(
	940	'format\|f=s' => \$format,
	941	);
	942
	943	my %possible_format = (
	944	txt => \&cmd_exportdb_txt,
	945	html => \&cmd_exportdb_html,
	946	);
	947
	948	$format = 'txt' if not defined $possible_format{$format};
[63]	949
[45]	950	$possible_format{$format}->(@ARGV);
[63]	951	return;
[45]	952	}
	953
	954	sub cmd_exportdb_txt {
[34]	955	test_maindb_environnement();
	956
[44]	957	my $computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE");
[2]	958
[78]	959	printf "%-26s %-4s %-40s %-15s %-18s %-16s %s\n", qw(Switch Port Hostname-FQ IPv4-Address MAC-Address Date VLAN);
	960	print "--------------------------------------------------------------------------------------------------------------------------------------------\n";
[2]	961
	962	LOOP_ON_IP_ADDRESS:
[63]	963	foreach my $ip (Net::Netmask::sort_by_ip_address(keys %{$computerdb})) {
	964
[2]	965	# next LOOP_ON_IP_ADDRESS if $computerdb->{$ip}{hostname_fq} eq 'unknow';
	966
	967	# to be improve in the future
	968	next LOOP_ON_IP_ADDRESS if $computerdb->{$ip}{hostname_fq} eq ($computerdb->{$ip}{switch_hostname} \|\| $computerdb->{$ip}{switch_description}); # switch on himself !
	969
	970	# dans le futur
	971	# next if $computerdb->{$ip}{hostname_fq} eq 'unknow';
[63]	972
	973	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime $computerdb->{$ip}{timestamp};
[2]	974	$year += 1900;
	975	$mon++;
[63]	976	my $date = sprintf '%04i-%02i-%02i %02i:%02i', $year, $mon, $mday, $hour, $min;
[2]	977
[78]	978	printf "%-27s %2s <------- %-40s %-15s %-18s %-16s %s\n",
[2]	979	$computerdb->{$ip}{switch_hostname} \|\| $computerdb->{$ip}{switch_description},
	980	$computerdb->{$ip}{switch_port},
	981	$computerdb->{$ip}{hostname_fq},
	982	$ip,
	983	$computerdb->{$ip}{mac_address},
[70]	984	$date,
	985	$computerdb->{$ip}{network} \|\| '';
[2]	986	}
[63]	987	return;
[2]	988	}
	989
[45]	990	sub cmd_exportdb_html {
	991	test_maindb_environnement();
	992
	993	my $computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE");
	994
	995	#<link rel="stylesheet" type="text/css" href="style-klask.css" />
	996	#<script src="sorttable-klask.js"></script>
	997
[63]	998	print <<'END_HTML';
[73]	999	<table class="sortable" summary="Klask Host Database">
[72]	1000	<caption>Klask Host Database</caption>
[45]	1001	<thead>
	1002	<tr>
[73]	1003	<th scope="col" class="klask-header-left">Switch</th>
[45]	1004	<th scope="col" class="sorttable_nosort">Port</th>
	1005	<th scope="col" class="sorttable_nosort">Link</th>
[73]	1006	<th scope="col" class="sorttable_alpha">Hostname-FQ</th>
[45]	1007	<th scope="col" class="hklask-ipv4">IPv4-Address</th>
[67]	1008	<th scope="col" class="sorttable_alpha">MAC-Address</th>
[71]	1009	<th scope="col" class="sorttable_alpha">VLAN</th>
[73]	1010	<th scope="col" class="klask-header-right">Date</th>
[45]	1011	</tr>
	1012	</thead>
	1013	<tfoot>
	1014	<tr>
[73]	1015	<th scope="col" class="klask-footer-left">Switch</th>
[45]	1016	<th scope="col" class="fklask-port">Port</th>
	1017	<th scope="col" class="fklask-link">Link</th>
[73]	1018	<th scope="col" class="fklask-hostname">Hostname-FQ</th>
[45]	1019	<th scope="col" class="fklask-ipv4">IPv4-Address</th>
	1020	<th scope="col" class="fklask-mac">MAC-Address</th>
[71]	1021	<th scope="col" class="fklask-vlan">VLAN</th>
[73]	1022	<th scope="col" class="klask-footer-right">Date</th>
[45]	1023	</tr>
	1024	</tfoot>
	1025	<tbody>
[63]	1026	END_HTML
[45]	1027
	1028	my %mac_count = ();
	1029	LOOP_ON_IP_ADDRESS:
[63]	1030	foreach my $ip (keys %{$computerdb}) {
	1031
[45]	1032	# to be improve in the future
	1033	next LOOP_ON_IP_ADDRESS if $computerdb->{$ip}{hostname_fq} eq ($computerdb->{$ip}{switch_hostname} \|\| $computerdb->{$ip}{switch_description}); # switch on himself !
[63]	1034
[45]	1035	$mac_count{$computerdb->{$ip}{mac_address}}++;
	1036	}
	1037
	1038	my $typerow = 'even';
	1039
	1040	LOOP_ON_IP_ADDRESS:
[63]	1041	foreach my $ip (Net::Netmask::sort_by_ip_address(keys %{$computerdb})) {
	1042
[45]	1043	# to be improve in the future
	1044	next LOOP_ON_IP_ADDRESS if $computerdb->{$ip}{hostname_fq} eq ($computerdb->{$ip}{switch_hostname} \|\| $computerdb->{$ip}{switch_description}); # switch on himself !
	1045
[63]	1046	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime $computerdb->{$ip}{timestamp};
[45]	1047	$year += 1900;
	1048	$mon++;
[63]	1049	my $date = sprintf '%04i-%02i-%02i %02i:%02i', $year, $mon, $mday, $hour, $min;
[45]	1050
	1051	# $odd_or_even++;
	1052	# my $typerow = $odd_or_even % 2 ? 'odd' : 'even';
[63]	1053	$typerow = $typerow eq 'even' ? 'odd' : 'even';
[45]	1054
	1055	my $switch_hostname = $computerdb->{$ip}{switch_hostname} \|\| $computerdb->{$ip}{switch_description} \|\| 'unkown';
	1056	chomp $switch_hostname;
[63]	1057	my $switch_hostname_sort = sprintf '%s %3s' ,$switch_hostname, $computerdb->{$ip}{switch_port};
[45]	1058
[63]	1059	my $ip_sort = sprintf '%03i%03i%03i%03i', split m/ \. /xms, $ip;
[45]	1060
[63]	1061	my $mac_sort = sprintf '%04i-%s', 9999 - $mac_count{$computerdb->{$ip}{mac_address}}, $computerdb->{$ip}{mac_address};
[45]	1062
[63]	1063	$computerdb->{$ip}{hostname_fq} = 'unknow' if $computerdb->{$ip}{hostname_fq} =~ m/^ \d+ \. \d+ \. \d+ \. \d+ $/xms;
	1064	my ( $host_short ) = split m/ \. /xms, $computerdb->{$ip}{hostname_fq};
[45]	1065
[71]	1066	my $vlan = $computerdb->{$ip}{network} \|\| '';
	1067
[63]	1068	print <<"END_HTML";
[45]	1069	<tr class="$typerow">
	1070	<td sorttable_customkey="$switch_hostname_sort">$switch_hostname</td>
	1071	<td class="bklask-port">$computerdb->{$ip}{switch_port}</td>
	1072	<td><-------</td>
	1073	<td sorttable_customkey="$host_short">$computerdb->{$ip}{hostname_fq}</td>
	1074	<td sorttable_customkey="$ip_sort">$ip</td>
	1075	<td sorttable_customkey="$mac_sort">$computerdb->{$ip}{mac_address}</td>
[71]	1076	<td>$vlan</td>
[45]	1077	<td>$date</td>
	1078	</tr>
[63]	1079	END_HTML
[45]	1080	}
	1081
	1082	my $switch_connection = YAML::Syck::LoadFile("$KLASK_SW_FILE");
	1083
	1084	my %db_switch_output_port = %{$switch_connection->{output_port}};
	1085	my %db_switch_parent = %{$switch_connection->{parent}};
	1086	my %db_switch_connected_on_port = %{$switch_connection->{connected_on_port}};
	1087	my %db_switch = %{$switch_connection->{switch_db}};
	1088
	1089	for my $sw (sort keys %db_switch_output_port) {
	1090
[63]	1091	my $switch_hostname_sort = sprintf '%s %3s' ,$sw, $db_switch_output_port{$sw};
[45]	1092
[63]	1093	$typerow = $typerow eq 'even' ? 'odd' : 'even';
[45]	1094
	1095	if (exists $db_switch_parent{$sw}) {
	1096
	1097	my $mac_address = $db_switch{$db_switch_parent{$sw}->{switch}}->{mac_address};
	1098	my $ipv4_address = $db_switch{$db_switch_parent{$sw}->{switch}}->{ipv4_address};
	1099	my $timestamp = $db_switch{$db_switch_parent{$sw}->{switch}}->{timestamp};
	1100
	1101	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime $timestamp;
	1102	$year += 1900;
	1103	$mon++;
[63]	1104	my $date = sprintf '%04i-%02i-%02i %02i:%02i', $year, $mon, $mday, $hour, $min;
[45]	1105
[63]	1106	my $ip_sort = sprintf '%03i%03i%03i%03i', split m/ \. /xms, $ipv4_address;
[45]	1107
[63]	1108	my $mac_sort = sprintf '%04i-%s', 9999, $mac_address;
[45]	1109
[63]	1110	my ( $host_short ) = sprintf '%s %3s' , split(m/ \. /xms, $db_switch_parent{$sw}->{switch}, 1), $db_switch_parent{$sw}->{port};
[45]	1111
[63]	1112	print <<"END_HTML";
[45]	1113	<tr class="$typerow">
	1114	<td sorttable_customkey="$switch_hostname_sort">$sw</td>
	1115	<td class="bklask-port">$db_switch_output_port{$sw}</>
	1116	<td>+--> $db_switch_parent{$sw}->{port}</td>
	1117	<td sorttable_customkey="$host_short">$db_switch_parent{$sw}->{switch}</>
	1118	<td sorttable_customkey="$ip_sort">$ipv4_address</td>
	1119	<td sorttable_customkey="$mac_sort">$mac_address</td>
[71]	1120	<td></td>
[45]	1121	<td>$date</td>
	1122	</tr>
[63]	1123	END_HTML
[45]	1124	}
	1125	else {
[63]	1126	print <<"END_HTML";
[45]	1127	<tr class="$typerow">
	1128	<td sorttable_customkey="$switch_hostname_sort">$sw</td>
	1129	<td class="bklask-port">$db_switch_output_port{$sw}</>
	1130	<td>+--></td>
	1131	<td sorttable_customkey="router">router</>
	1132	<td sorttable_customkey="999999999999"></td>
	1133	<td sorttable_customkey="99999"></td>
	1134	<td></td>
[71]	1135	<td></td>
[45]	1136	</tr>
[63]	1137	END_HTML
[45]	1138	}
	1139	}
	1140
	1141	for my $swport (sort keys %db_switch_connected_on_port) {
[63]	1142	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[45]	1143	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1144
[63]	1145	my $switch_hostname_sort = sprintf '%s %3s' ,$sw_connect, $port_connect;
[45]	1146
	1147	my $mac_address = $db_switch{$sw}->{mac_address};
	1148	my $ipv4_address = $db_switch{$sw}->{ipv4_address};
	1149	my $timestamp = $db_switch{$sw}->{timestamp};
	1150
	1151	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime $timestamp;
	1152	$year += 1900;
	1153	$mon++;
[63]	1154	my $date = sprintf '%04i-%02i-%02i %02i:%02i', $year,$mon,$mday,$hour,$min;
[45]	1155
[63]	1156	my $ip_sort = sprintf '%03i%03i%03i%03i', split m/ \. /xms, $ipv4_address;
[45]	1157
[63]	1158	my $mac_sort = sprintf '%04i-%s', 9999, $mac_address;
[45]	1159
[63]	1160	$typerow = $typerow eq 'even' ? 'odd' : 'even';
[45]	1161
	1162	if (exists $db_switch_output_port{$sw}) {
	1163
[63]	1164	my ( $host_short ) = sprintf '%s %3s' , split( m/\./xms, $sw, 1), $db_switch_output_port{$sw};
[45]	1165
[63]	1166	print <<"END_HTML";
[45]	1167	<tr class="$typerow">
	1168	<td sorttable_customkey="$switch_hostname_sort">$sw_connect</td>
	1169	<td class="bklask-port">$port_connect</>
	1170	<td><--+ $db_switch_output_port{$sw}</td>
	1171	<td sorttable_customkey="$host_short">$sw</>
	1172	<td sorttable_customkey="$ip_sort">$ipv4_address</td>
	1173	<td sorttable_customkey="$mac_sort">$mac_address</td>
[71]	1174	<td></td>
[45]	1175	<td>$date</td>
	1176	</tr>
[63]	1177	END_HTML
[45]	1178	}
	1179	else {
[63]	1180	print <<"END_HTML";
[45]	1181	<tr class="$typerow">
	1182	<td sorttable_customkey="$switch_hostname_sort">$sw_connect</td>
	1183	<td class="bklask-port">$port_connect</>
	1184	<td><--+</td>
	1185	<td sorttable_customkey="$sw">$sw</>
	1186	<td sorttable_customkey="">$ipv4_address</td>
	1187	<td sorttable_customkey="">$mac_address</td>
[71]	1188	<td></td>
[45]	1189	<td>$date</td>
	1190	</tr>
[63]	1191	END_HTML
[45]	1192	}
	1193	}
	1194	}
	1195
[63]	1196	print <<'END_HTML';
[45]	1197	</tbody>
	1198	</table>
[63]	1199	END_HTML
	1200	return;
[45]	1201	}
	1202
[2]	1203	sub cmd_iplocation {
[44]	1204	my $computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE");
[2]	1205
	1206	LOOP_ON_IP_ADDRESS:
[63]	1207	foreach my $ip (Net::Netmask::sort_by_ip_address(keys %{$computerdb})) {
[2]	1208
	1209	next LOOP_ON_IP_ADDRESS if $computerdb->{$ip}{hostname_fq} eq ($computerdb->{$ip}{switch_hostname} \|\| $computerdb->{$ip}{switch_description}); # switch on himself !
	1210
[63]	1211	my $sw_hostname = $computerdb->{$ip}{switch_hostname} \|\| q{};
[2]	1212	next if $sw_hostname eq 'unknow';
[63]	1213
	1214	my $sw_location = q{};
[11]	1215	for my $sw (@SWITCH) {
[2]	1216	next if $sw_hostname ne $sw->{hostname};
	1217	$sw_location = $sw->{location};
	1218	last;
	1219	}
	1220
[63]	1221	printf "%s: \"%s\"\n", $ip, $sw_location if not $sw_location eq q{};
[2]	1222	}
[63]	1223	return;
[2]	1224	}
	1225
[69]	1226	sub cmd_ip_free {
	1227	my @vlan_name = @_;
	1228
	1229	my $days_to_dead = 365 * 2;
	1230	my $format = 'txt';
	1231
	1232	my $ret = GetOptionsFromArray(\@vlan_name,
	1233	'day\|d=i' => \$days_to_dead,
	1234	'format\|f=s' => \$format,
	1235	);
	1236
[72]	1237	my %possible_format = (
	1238	txt => \&cmd_ip_free_txt,
	1239	html => \&cmd_ip_free_html,
	1240	);
	1241	$format = 'txt' if not defined $possible_format{$format};
	1242
[69]	1243	@vlan_name = get_list_network() if not @vlan_name;
	1244
	1245	my $computerdb = {};
	1246	$computerdb = YAML::Syck::LoadFile("$KLASK_DB_FILE") if -e "$KLASK_DB_FILE";
	1247	my $timestamp = time;
	1248
	1249	my $timestamp_barrier = $timestamp - (3600 * 24 * $days_to_dead );
	1250
[72]	1251	my %result_ip = ();
[69]	1252
	1253	ALL_NETWORK:
	1254	for my $vlan (@vlan_name) {
	1255
	1256	my @ip_list = get_list_ip($vlan);
	1257	# my $current_interface = get_current_interface($vlan);
	1258
	1259	LOOP_ON_IP_ADDRESS:
	1260	for my $ip (@ip_list) {
	1261
	1262	next LOOP_ON_IP_ADDRESS if
	1263	exists $computerdb->{$ip}
	1264	&& $computerdb->{$ip}{timestamp} > $timestamp_barrier;
	1265
	1266	my $ip_date_last_detection = '';
	1267	if (exists $computerdb->{$ip}) {
	1268	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime $computerdb->{$ip}{timestamp};
	1269	$year += 1900;
	1270	$mon++;
	1271	$ip_date_last_detection = sprintf '%04i-%02i-%02i %02i:%02i', $year, $mon, $mday, $hour, $min;
	1272	}
	1273
	1274	$result_ip{$ip} \|\|= {};
	1275	$result_ip{$ip}->{date_last_detection} = $ip_date_last_detection;
	1276
	1277	my $packed_ip = scalar gethostbyname($ip);
	1278	my $hostname_fq = 'unknown';
	1279	$hostname_fq = scalar gethostbyaddr($packed_ip, AF_INET) \|\| 'unknown' if defined $packed_ip;
	1280	$result_ip{$ip}->{hostname_fq} = $hostname_fq;
	1281
	1282	$result_ip{$ip}->{vlan} = $vlan;
	1283	}
	1284	}
	1285
[72]	1286	$possible_format{$format}->(%result_ip);
	1287	}
	1288
	1289	sub cmd_ip_free_txt {
	1290	my %result_ip = @_;
	1291
[69]	1292	printf "%-15s %-40s %-16s %s\n", qw(IPv4-Address Hostname-FQ Date VLAN);
	1293	print "-------------------------------------------------------------------------------\n";
[72]	1294	LOOP_ON_IP_ADDRESS:
[69]	1295	foreach my $ip (Net::Netmask::sort_by_ip_address(keys %result_ip)) {
	1296	printf "%-15s %-40s %-16s %s\n", $ip, $result_ip{$ip}->{hostname_fq}, $result_ip{$ip}->{date_last_detection}, $result_ip{$ip}->{vlan};
	1297	}
	1298	}
	1299
[72]	1300	sub cmd_ip_free_html {
	1301	my %result_ip = @_;
	1302
	1303	print <<'END_HTML';
[73]	1304	<table class="sortable" summary="Klask Free IP Database">
	1305	<caption>Klask Free IP Database</caption>
[72]	1306	<thead>
	1307	<tr>
[73]	1308	<th scope="col" class="klask-header-left">IPv4-Address</th>
[72]	1309	<th scope="col" class="sorttable_alpha">Hostname-FQ</th>
	1310	<th scope="col" class="sorttable_alpha">VLAN</th>
[73]	1311	<th scope="col" class="klask-header-right">Date</th>
[72]	1312	</tr>
	1313	</thead>
	1314	<tfoot>
	1315	<tr>
[73]	1316	<th scope="col" class="klask-footer-left">IPv4-Address</th>
	1317	<th scope="col" class="fklask-hostname">Hostname-FQ</th>
[72]	1318	<th scope="col" class="fklask-vlan">VLAN</th>
[73]	1319	<th scope="col" class="klask-footer-right">Date</th>
[72]	1320	</tr>
	1321	</tfoot>
	1322	<tbody>
	1323	END_HTML
	1324
	1325	my $typerow = 'even';
	1326
	1327	LOOP_ON_IP_ADDRESS:
	1328	foreach my $ip (Net::Netmask::sort_by_ip_address(keys %result_ip)) {
	1329
	1330	$typerow = $typerow eq 'even' ? 'odd' : 'even';
	1331
	1332	my $ip_sort = sprintf '%03i%03i%03i%03i', split m/ \. /xms, $ip;
	1333	my ( $host_short ) = split m/ \. /xms, $result_ip{$ip}->{hostname_fq};
	1334
	1335	print <<"END_HTML";
	1336	<tr class="$typerow">
	1337	<td sorttable_customkey="$ip_sort">$ip</td>
	1338	<td sorttable_customkey="$host_short">$result_ip{$ip}->{hostname_fq}</td>
	1339	<td>$result_ip{$ip}->{vlan}</td>
	1340	<td>$result_ip{$ip}->{date_last_detection}</td>
	1341	</tr>
	1342	END_HTML
	1343	}
	1344	print <<'END_HTML';
	1345	</tbody>
	1346	</table>
	1347	END_HTML
	1348	}
	1349
[2]	1350	sub cmd_enable {
	1351	my $switch = shift;
	1352	my $port = shift;
[63]	1353
	1354	#snmpset -v 1 -c community X.X.X.X 1.3.6.1.2.1.2.2.1.7.NoPort = 1 (up)
	1355	#snmpset -v 1 -c community X.X.X.X 1.3.6.1.2.1.2.2.1.7.NoPort = 2 (down)
[2]	1356	system "snmpset -v 1 -c public $switch 1.3.6.1.2.1.2.2.1.7.$port = 1";
[63]	1357	return;
[2]	1358	}
	1359
	1360	sub cmd_disable {
	1361	my $switch = shift;
	1362	my $port = shift;
[63]	1363
[2]	1364	system "snmpset -v 1 -c public $switch 1.3.6.1.2.1.2.2.1.7.$port = 2";
[63]	1365	return;
[2]	1366	}
	1367
	1368	sub cmd_status {
	1369	my $switch = shift;
	1370	my $port = shift;
[63]	1371
[2]	1372	system "snmpget -v 1 -c public $switch 1.3.6.1.2.1.2.2.1.7.$port";
[63]	1373	return;
[2]	1374	}
	1375
[35]	1376	sub cmd_search_mac_on_switch {
[63]	1377	my $switch_name = shift \|\| q{};
	1378	my $mac_address = shift \|\| q{};
	1379
	1380	if ($switch_name eq q{} or $mac_address eq q{}) {
[39]	1381	die "Usage: klask search-mac-on-switch SWITCH_NAME MAC_ADDRESS\n";
[38]	1382	}
[39]	1383
	1384	if (not defined $SWITCH_DB{$switch_name}) {
[63]	1385	die "Switch $switch_name must be defined in klask configuration file\n";
[39]	1386	}
	1387
	1388	my $sw = $SWITCH_DB{$switch_name};
	1389	my %session = ( -hostname => $sw->{hostname} );
	1390	$session{-version} = $sw->{version} \|\| 1;
	1391	$session{-port} = $sw->{snmpport} \|\| $DEFAULT{snmpport} \|\| 161;
[63]	1392	if (exists $sw->{version} and $sw->{version} eq '3') {
[39]	1393	$session{-username} = $sw->{username} \|\| 'snmpadmin';
	1394	}
	1395	else {
	1396	$session{-community} = $sw->{community} \|\| $DEFAULT{community} \|\| 'public';
	1397	}
	1398
[63]	1399	my $research = '1.3.6.1.2.1.17.4.3.1.2' . arp_hex_to_dec($mac_address);
[35]	1400	print "Klask search OID $research on switch $switch_name\n";
[2]	1401
[39]	1402	my ($session, $error) = Net::SNMP->session( %session );
[35]	1403	print "$error \n" if $error;
	1404
	1405	my $result = $session->get_request(
	1406	-varbindlist => [$research]
	1407	);
[63]	1408
	1409	if (not defined $result or $result->{$research} eq 'noSuchInstance') {
[35]	1410	print "Klask do not find MAC $mac_address on switch $switch_name\n";
	1411	$session->close;
	1412	}
	1413
	1414	my $swport = $result->{$research};
	1415	$session->close;
	1416
	1417	print "Klask find MAC $mac_address on switch $switch_name port $swport\n";
[63]	1418	return;
[35]	1419	}
	1420
[4]	1421	sub cmd_updatesw {
[2]	1422
[4]	1423	init_switch_names('yes'); #nomme les switchs
[2]	1424	print "\n";
	1425
	1426	my %where = ();
	1427	my %db_switch_output_port = ();
	1428	my %db_switch_ip_hostname = ();
	1429
	1430	DETECT_ALL_ROUTER:
[9]	1431	# for my $one_computer ('194.254.66.254') {
[11]	1432	for my $one_router ( get_list_main_router(get_list_network()) ) {
[63]	1433	my %resol_arp = resolve_ip_arp_host($one_router, q{*}, q{low}); # resolution arp
[2]	1434	next DETECT_ALL_ROUTER if $resol_arp{mac_address} eq 'unknow';
[13]	1435	$where{$resol_arp{ipv4_address}} = find_all_switch_port($resol_arp{mac_address}); # retrouve les emplacements des routeurs
[2]	1436	}
	1437
	1438	ALL_ROUTER_IP_ADDRESS:
[13]	1439	for my $ip (Net::Netmask::sort_by_ip_address(keys %where)) { # '194.254.66.254')) {
[63]	1440
[13]	1441	next ALL_ROUTER_IP_ADDRESS if not exists $where{$ip}; # /a priori/ idiot car ne sers à rien...
[2]	1442
	1443	ALL_SWITCH_CONNECTED:
	1444	for my $switch_detected ( keys %{$where{$ip}} ) {
	1445
	1446	my $switch = $where{$ip}->{$switch_detected};
	1447
	1448	next ALL_SWITCH_CONNECTED if $switch->{port} eq '0';
[63]	1449
[2]	1450	$db_switch_output_port{$switch->{hostname}} = $switch->{port};
	1451	}
[63]	1452	}
[2]	1453
	1454	my %db_switch_link_with = ();
	1455
	1456	my @list_switch_ip = ();
	1457	my @list_switch_ipv4 = ();
[11]	1458	for my $sw (@SWITCH){
[2]	1459	push @list_switch_ip, $sw->{hostname};
	1460	}
	1461
[45]	1462	my $timestamp = time;
	1463
[2]	1464	ALL_SWITCH:
	1465	for my $one_computer (@list_switch_ip) {
[63]	1466	my %resol_arp = resolve_ip_arp_host($one_computer, q{*}, q{low}); # arp resolution
[2]	1467	next ALL_SWITCH if $resol_arp{mac_address} eq 'unknow';
[63]	1468
[2]	1469	push @list_switch_ipv4,$resol_arp{ipv4_address};
[63]	1470
[2]	1471	$where{$resol_arp{ipv4_address}} = find_all_switch_port($resol_arp{mac_address}); # find port on all switch
[68]	1472	#my @l = ();
	1473	#for my $c ( keys %{$where{$resol_arp{ipv4_address}}} ) {
	1474	#push @l, "$c -+ "; #$where{$resol_arp{ipv4_address}}->{$c}{hostname};
	1475	#}
	1476	#print "DEBUG $one_computer $resol_arp{ipv4_address} $resol_arp{mac_address} --- @l\n";
[2]	1477
	1478	$db_switch_ip_hostname{$resol_arp{ipv4_address}} = $resol_arp{hostname_fq};
[45]	1479
	1480	$SWITCH_DB{$one_computer}->{ipv4_address} = $resol_arp{ipv4_address};
	1481	$SWITCH_DB{$one_computer}->{mac_address} = $resol_arp{mac_address};
	1482	$SWITCH_DB{$one_computer}->{timestamp} = $timestamp;
[2]	1483	}
[63]	1484
[2]	1485	ALL_SWITCH_IP_ADDRESS:
	1486	for my $ip (Net::Netmask::sort_by_ip_address(@list_switch_ipv4)) {
[63]	1487
[2]	1488	next ALL_SWITCH_IP_ADDRESS if not exists $where{$ip};
	1489
	1490	DETECTED_SWITCH:
	1491	for my $switch_detected ( keys %{$where{$ip}} ) {
	1492
[15]	1493	next DETECTED_SWITCH if not exists $SWITCH_PORT_COUNT{ $db_switch_ip_hostname{$ip}};
[2]	1494
	1495	my $switch = $where{$ip}->{$switch_detected};
[68]	1496	#print "DEBUG1 : $db_switch_ip_hostname{$ip} / $switch->{hostname} : $switch->{port}\n" if $switch->{hostname} =~ m/sw3-batA0-3s/;
[2]	1497
	1498	next if $switch->{port} eq '0';
	1499	next if $switch->{port} eq $db_switch_output_port{$switch->{hostname}};
	1500	next if $switch->{hostname} eq $db_switch_ip_hostname{$ip}; # $computerdb->{$ip}{hostname};
	1501
	1502	$db_switch_link_with{ $db_switch_ip_hostname{$ip} } \|\|= {};
	1503	$db_switch_link_with{ $db_switch_ip_hostname{$ip} }->{ $switch->{hostname} } = $switch->{port};
[68]	1504	#print "DEBUG : $db_switch_ip_hostname{$ip} / $switch->{hostname} : $switch->{port}\n" if $switch->{hostname} !~ m/sw3-batA0-3s/;
[2]	1505	}
	1506
	1507	}
[63]	1508
[2]	1509	my %db_switch_connected_on_port = ();
	1510	my $maybe_more_than_one_switch_connected = 'yes';
[63]	1511
[2]	1512	while ($maybe_more_than_one_switch_connected eq 'yes') {
	1513	for my $sw (keys %db_switch_link_with) {
	1514	for my $connect (keys %{$db_switch_link_with{$sw}}) {
[63]	1515
[2]	1516	my $port = $db_switch_link_with{$sw}->{$connect};
[63]	1517
[2]	1518	$db_switch_connected_on_port{"$connect:$port"} \|\|= {};
	1519	$db_switch_connected_on_port{"$connect:$port"}->{$sw}++; # Just to define the key
	1520	}
	1521	}
	1522
	1523	$maybe_more_than_one_switch_connected = 'no';
	1524
	1525	SWITCH_AND_PORT:
	1526	for my $swport (keys %db_switch_connected_on_port) {
[63]	1527
[2]	1528	next if keys %{$db_switch_connected_on_port{$swport}} == 1;
[63]	1529
[2]	1530	$maybe_more_than_one_switch_connected = 'yes';
	1531
[63]	1532	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1533	my @sw_on_same_port = keys %{$db_switch_connected_on_port{$swport}};
	1534
	1535	CONNECTED:
	1536	for my $sw_connected (@sw_on_same_port) {
[63]	1537
[2]	1538	next CONNECTED if not keys %{$db_switch_link_with{$sw_connected}} == 1;
[63]	1539
[2]	1540	$db_switch_connected_on_port{$swport} = {$sw_connected => 1};
[63]	1541
[2]	1542	for my $other_sw (@sw_on_same_port) {
	1543	next if $other_sw eq $sw_connected;
[63]	1544
[2]	1545	delete $db_switch_link_with{$other_sw}->{$sw_connect};
	1546	}
[63]	1547
[2]	1548	# We can not do better for this switch for this loop
	1549	next SWITCH_AND_PORT;
	1550	}
	1551	}
	1552	}
	1553
	1554	my %db_switch_parent =();
	1555
	1556	for my $sw (keys %db_switch_link_with) {
	1557	for my $connect (keys %{$db_switch_link_with{$sw}}) {
[63]	1558
[2]	1559	my $port = $db_switch_link_with{$sw}->{$connect};
[63]	1560
[2]	1561	$db_switch_connected_on_port{"$connect:$port"} \|\|= {};
	1562	$db_switch_connected_on_port{"$connect:$port"}->{$sw} = $port;
[63]	1563
[2]	1564	$db_switch_parent{$sw} = {switch => $connect, port => $port};
	1565	}
	1566	}
	1567
[63]	1568	print "Switch output port and parent port connection\n";
[2]	1569	print "---------------------------------------------\n";
	1570	for my $sw (sort keys %db_switch_output_port) {
	1571	if (exists $db_switch_parent{$sw}) {
[78]	1572	printf "%-27s %2s +--> %2s %-25s\n", $sw, $db_switch_output_port{$sw}, $db_switch_parent{$sw}->{port}, $db_switch_parent{$sw}->{switch};
[2]	1573	}
	1574	else {
[78]	1575	printf "%-27s %2s +--> router\n", $sw, $db_switch_output_port{$sw};
[2]	1576	}
	1577	}
	1578	print "\n";
	1579
	1580	print "Switch parent and children port inter-connection\n";
	1581	print "------------------------------------------------\n";
[63]	1582	for my $swport (sort keys %db_switch_connected_on_port) {
	1583	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1584	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1585	if (exists $db_switch_output_port{$sw}) {
[78]	1586	printf "%-27s %2s <--+ %2s %-25s\n", $sw_connect, $port_connect, $db_switch_output_port{$sw}, $sw;
[2]	1587	}
	1588	else {
[78]	1589	printf "%-27s %2s <--+ %-25s\n", $sw_connect, $port_connect, $sw;
[2]	1590	}
	1591	}
	1592	}
	1593
	1594	my $switch_connection = {
	1595	output_port => \%db_switch_output_port,
	1596	parent => \%db_switch_parent,
	1597	connected_on_port => \%db_switch_connected_on_port,
	1598	link_with => \%db_switch_link_with,
[25]	1599	switch_db => \%SWITCH_DB,
[2]	1600	};
[63]	1601
[44]	1602	YAML::Syck::DumpFile("$KLASK_SW_FILE", $switch_connection);
[63]	1603	return;
[2]	1604	}
	1605
[4]	1606	sub cmd_exportsw {
	1607	my @ARGV = @_;
[2]	1608
[34]	1609	test_switchdb_environnement();
	1610
[4]	1611	my $format = 'txt';
	1612
	1613	my $ret = GetOptions(
	1614	'format\|f=s' => \$format,
	1615	);
	1616
	1617	my %possible_format = (
	1618	txt => \&cmd_exportsw_txt,
	1619	dot => \&cmd_exportsw_dot,
	1620	);
	1621
	1622	$format = 'txt' if not defined $possible_format{$format};
[63]	1623
[4]	1624	$possible_format{$format}->(@ARGV);
[63]	1625	return;
[4]	1626	}
	1627
	1628	sub cmd_exportsw_txt {
	1629
[44]	1630	my $switch_connection = YAML::Syck::LoadFile("$KLASK_SW_FILE");
[4]	1631
	1632	my %db_switch_output_port = %{$switch_connection->{output_port}};
	1633	my %db_switch_parent = %{$switch_connection->{parent}};
	1634	my %db_switch_connected_on_port = %{$switch_connection->{connected_on_port}};
	1635
[63]	1636	print "Switch output port and parent port connection\n";
[4]	1637	print "---------------------------------------------\n";
	1638	for my $sw (sort keys %db_switch_output_port) {
	1639	if (exists $db_switch_parent{$sw}) {
[78]	1640	printf "%-27s %2s +--> %2s %-25s\n", $sw, $db_switch_output_port{$sw}, $db_switch_parent{$sw}->{port}, $db_switch_parent{$sw}->{switch};
[4]	1641	}
	1642	else {
[78]	1643	printf "%-27s %2s +--> router\n", $sw, $db_switch_output_port{$sw};
[4]	1644	}
	1645	}
	1646	print "\n";
	1647
	1648	print "Switch parent and children port inter-connection\n";
	1649	print "------------------------------------------------\n";
[63]	1650	for my $swport (sort keys %db_switch_connected_on_port) {
	1651	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[4]	1652	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1653	if (exists $db_switch_output_port{$sw}) {
[78]	1654	printf "%-27s %2s <--+ %2s %-25s\n", $sw_connect, $port_connect, $db_switch_output_port{$sw}, $sw;
[4]	1655	}
	1656	else {
[78]	1657	printf "%-27s %2s <--+ %-25s\n", $sw_connect, $port_connect, $sw;
[4]	1658	}
	1659	}
	1660	}
[63]	1661	return;
[4]	1662	}
	1663
	1664	sub cmd_exportsw_dot {
	1665
[44]	1666	my $switch_connection = YAML::Syck::LoadFile("$KLASK_SW_FILE");
[63]	1667
[2]	1668	my %db_switch_output_port = %{$switch_connection->{output_port}};
	1669	my %db_switch_parent = %{$switch_connection->{parent}};
	1670	my %db_switch_connected_on_port = %{$switch_connection->{connected_on_port}};
	1671	my %db_switch_link_with = %{$switch_connection->{link_with}};
[25]	1672	my %db_switch_global = %{$switch_connection->{switch_db}};
	1673
[2]	1674	my %db_building= ();
[11]	1675	for my $sw (@SWITCH) {
[63]	1676	my ($building, $location) = split m/ \/ /xms, $sw->{location}, 2;
[2]	1677	$db_building{$building} \|\|= {};
	1678	$db_building{$building}->{$location} \|\|= {};
	1679	$db_building{$building}->{$location}{ $sw->{hostname} } = 'y';
	1680	}
[63]	1681
	1682
[2]	1683	print "digraph G {\n";
	1684
[4]	1685	print "site [label = \"site\", color = black, fillcolor = gold, shape = invhouse, style = filled];\n";
	1686	print "internet [label = \"internet\", color = black, fillcolor = cyan, shape = house, style = filled];\n";
[2]	1687
	1688	my $b=0;
	1689	for my $building (keys %db_building) {
	1690	$b++;
[63]	1691
[4]	1692	print "\"building$b\" [label = \"$building\", color = black, fillcolor = gold, style = filled];\n";
	1693	print "site -> \"building$b\" [len = 2, color = firebrick];\n";
[2]	1694
	1695	my $l = 0;
	1696	for my $loc (keys %{$db_building{$building}}) {
	1697	$l++;
[63]	1698
	1699	print "\"location$b-$l\" [label = \"$building" . q{/} . join(q{\n}, split(m{ / }xms, $loc)) . "\", color = black, fillcolor = orange, style = filled];\n";
[33]	1700	# print "\"location$b-$l\" [label = \"$building / $loc\", color = black, fillcolor = orange, style = filled];\n";
[4]	1701	print "\"building$b\" -> \"location$b-$l\" [len = 2, color = firebrick]\n";
[2]	1702
	1703	for my $sw (keys %{$db_building{$building}->{$loc}}) {
	1704
	1705	print "\"$sw:$db_switch_output_port{$sw}\" [label = $db_switch_output_port{$sw}, color = black, fillcolor = lightblue, peripheries = 2, style = filled];\n";
	1706
[25]	1707	my $swname = $sw;
[63]	1708	$swname .= q{\n-\n} . "$db_switch_global{$sw}->{model}" if exists $db_switch_global{$sw} and exists $db_switch_global{$sw}->{model};
[25]	1709	print "\"$sw\" [label = \"$swname\", color = black, fillcolor = palegreen, shape = rect, style = filled];\n";
[4]	1710	print "\"location$b-$l\" -> \"$sw\" [len = 2, color = firebrick, arrowtail = dot]\n";
	1711	print "\"$sw\" -> \"$sw:$db_switch_output_port{$sw}\" [len=2, style=bold, arrowhead = normal, arrowtail = invdot]\n";
[2]	1712
	1713
	1714	for my $swport (keys %db_switch_connected_on_port) {
[63]	1715	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1716	next if not $sw_connect eq $sw;
	1717	next if $port_connect eq $db_switch_output_port{$sw};
	1718	print "\"$sw:$port_connect\" [label = $port_connect, color = black, fillcolor = plum, peripheries = 1, style = filled];\n";
[4]	1719	print "\"$sw:$port_connect\" -> \"$sw\" [len=2, style=bold, arrowhead= normal, arrowtail = inv]\n";
[2]	1720	}
	1721	}
	1722	}
	1723	}
	1724
[63]	1725	# print "Switch output port and parent port connection\n";
[2]	1726	# print "---------------------------------------------\n";
	1727	for my $sw (sort keys %db_switch_output_port) {
	1728	if (exists $db_switch_parent{$sw}) {
	1729	# printf " \"%s:%s\" -> \"%s:%s\"\n", $sw, $db_switch_output_port{$sw}, $db_switch_parent{$sw}->{switch}, $db_switch_parent{$sw}->{port};
	1730	}
	1731	else {
	1732	printf " \"%s:%s\" -> internet\n", $sw, $db_switch_output_port{$sw};
	1733	}
	1734	}
	1735	print "\n";
	1736
	1737	# print "Switch parent and children port inter-connection\n";
	1738	# print "------------------------------------------------\n";
[63]	1739	for my $swport (sort keys %db_switch_connected_on_port) {
	1740	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1741	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1742	if (exists $db_switch_output_port{$sw}) {
	1743	printf " \"%s:%s\" -> \"%s:%s\" [color = navyblue]\n", $sw, $db_switch_output_port{$sw}, $sw_connect, $port_connect;
	1744	}
	1745	else {
	1746	printf " \"%s\" -> \"%s%s\"\n", $sw, $sw_connect, $port_connect;
	1747	}
	1748	}
	1749	}
	1750
	1751	print "}\n";
[63]	1752	return;
[2]	1753	}
	1754
	1755
	1756	__END__
	1757
	1758	=head1 NAME
	1759
	1760	klask - ports manager and finder for switch
	1761
	1762
[63]	1763	=head1 USAGE
[2]	1764
	1765	klask updatedb
[45]	1766	klask exportdb --format [txt\|html]
[76]	1767	klask removedb computer*
[75]	1768	klask cleandb --day number_of_day --verbose
[2]	1769
[5]	1770	klask updatesw
	1771	klask exportsw --format [txt\|dot]
	1772
[2]	1773	klask searchdb computer
	1774	klask search computer
[69]	1775	klask search-mac-on-switch switch mac_addr
[2]	1776
[76]	1777	klask ip-free --day number_of_day --format [txt\|html] [vlan_name]
[69]	1778
[2]	1779	klask enable switch port
	1780	klask disable swith port
	1781	klask status swith port
	1782
	1783
	1784	=head1 DESCRIPTION
	1785
[6]	1786	klask is a small tool to find where is a host in a big network. klask mean search in brittany.
[2]	1787
[6]	1788	Klask has now a web site dedicated for it !
[2]	1789
[6]	1790	http://servforge.legi.inpg.fr/projects/klask
	1791
	1792
[2]	1793	=head1 COMMANDS
	1794
	1795
	1796	=head2 search
	1797
	1798	This command takes one or more computer in argument. It search a computer on the network and give the port and the switch on which the computer is connected.
	1799
	1800
	1801	=head2 enable
	1802
	1803	This command activate a port on a switch by snmp. So you need to give the switch and the port number on the command line.
	1804
	1805
	1806	=head2 disable
	1807
	1808	This command deactivate a port on a switch by snmp. So you need to give the switch and the port number on the command line.
	1809
	1810
	1811	=head2 status
	1812
	1813	This command return the status of a port number on a switch by snmp. So you need to give the switch name and the port number on the command line.
	1814
	1815
	1816	=head2 updatedb
	1817
	1818	This command will scan networks and update a database. To know which are the cmputer scan, you have to configure the file /etc/klask.conf This file is easy to read and write because klask use YAML format and not XML.
	1819
	1820
	1821	=head2 exportdb
	1822
	1823	This command print the content of the database. There is actually only one format. It's very easy to have more format, it's just need times...
	1824
	1825
[5]	1826	=head2 updatesw
	1827
	1828	This command build a map of your manageable switch on your network. The list of the switch must be given in the file /etc/klask.conf.
	1829
	1830
	1831	=head2 exportsw --format [txt\|dot]
	1832
	1833	This command print the content of the switch database. There is actually two format. One is just txt for terminal and the other is the dot format from the graphviz environnement.
	1834
	1835	klask exportsw --format dot > /tmp/map.dot
	1836	dot -Tpng /tmp/map.dot > /tmp/map.png
	1837
	1838
	1839
[2]	1840	=head1 CONFIGURATION
	1841
	1842	Because klask need many parameters, it's not possible actually to use command line parameters. The configuration is done in a /etc/klask.conf YAML file. This format have many advantage over XML, it's easier to read and to write !
	1843
	1844	Here an example, be aware with indent, it's important in YAML, do not use tabulation !
	1845
	1846	default:
	1847	community: public
	1848	snmpport: 161
	1849
	1850	network:
[5]	1851	labnet:
	1852	ip-subnet:
	1853	- add: 192.168.1.0/24
	1854	- add: 192.168.2.0/24
	1855	interface: eth0
	1856	main-router: gw1.labnet.local
[2]	1857
[5]	1858	schoolnet:
	1859	ip-subnet:
	1860	- add: 192.168.6.0/24
	1861	- add: 192.168.7.0/24
	1862	interface: eth0.38
	1863	main-router: gw2.schoolnet.local
	1864
[2]	1865	switch:
	1866	- hostname: sw1.klask.local
	1867	portignore:
	1868	- 1
	1869	- 2
	1870
	1871	- hostname: sw2.klask.local
[5]	1872	location: BatK / 2 / K203
	1873	type: HP2424
[2]	1874	portignore:
	1875	- 1
	1876	- 2
	1877
	1878	I think it's pretty easy to understand. The default section can be overide in any section, if parameter mean something in theses sections. Network to be scan are define in the network section. You must put a add by network. Maybe i will make a delete line to suppress specific computers. The switch section define your switch. You have to write the port number to ignore, this is important if your switchs are cascade. Juste put the ports numbers between switch.
	1879
	1880
	1881	=head1 FILES
	1882
	1883	/etc/klask.conf
	1884	/var/cache/klask/klaskdb
[7]	1885	/var/cache/klask/switchdb
[2]	1886
	1887	=head1 SEE ALSO
	1888
	1889	Net::SNMP, Net::Netmask, Net::CIDR::Lite, NetAddr::IP, YAML
	1890
	1891
	1892	=head1 VERSION
	1893
[36]	1894	$Id: klask 78 2011-03-24 17:33:19Z g7moreau $
[2]	1895
	1896
	1897	=head1 AUTHOR
	1898
[5]	1899	Written by Gabriel Moreau, Grenoble - France
[2]	1900
	1901
[63]	1902	=head1 LICENSE AND COPYRIGHT
[2]	1903
	1904	GPL version 2 or later and Perl equivalent
[45]	1905
[63]	1906	Copyright (C) 2005-2009 Gabriel Moreau.

Note: See TracBrowser for help on using the repository browser.

Download in other formats: