Context Navigation

source: trunk/klask @ 80

Last change on this file since 80 was 80, checked in by g7moreau, 13 years ago
Add one mode DEBUG print in updatesw command
Property svn:executable set to ``* Property svn:keywords set to `Date Author Id Rev`
File size: 62.2 KB

Rev	Line
[2]	1	#!/usr/bin/perl -w
[32]	2	#
	3	# Copyright (C) 2005-2008 Gabriel Moreau.
	4	#
	5	# $Id: klask 80 2011-03-29 15:57:13Z 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
[79]	24	# arping net-tools 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";
[79]	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";}
[68]	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: 80 $'."\n";
	619	print ' $Date: 2011-03-29 15:57:13 +0000 (Tue, 29 Mar 2011) $'."\n";
	620	print ' $Id: klask 80 2011-03-29 15:57:13Z 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 {
[79]	1422	my @options = @_;
[2]	1423
[79]	1424	my $verbose;
	1425
	1426	my $ret = GetOptionsFromArray(\@options,
	1427	'verbose\|v' => \$verbose,
	1428	);
	1429
[4]	1430	init_switch_names('yes'); #nomme les switchs
[2]	1431	print "\n";
	1432
	1433	my %where = ();
	1434	my %db_switch_output_port = ();
	1435	my %db_switch_ip_hostname = ();
	1436
	1437	DETECT_ALL_ROUTER:
[9]	1438	# for my $one_computer ('194.254.66.254') {
[11]	1439	for my $one_router ( get_list_main_router(get_list_network()) ) {
[63]	1440	my %resol_arp = resolve_ip_arp_host($one_router, q{*}, q{low}); # resolution arp
[2]	1441	next DETECT_ALL_ROUTER if $resol_arp{mac_address} eq 'unknow';
[13]	1442	$where{$resol_arp{ipv4_address}} = find_all_switch_port($resol_arp{mac_address}); # retrouve les emplacements des routeurs
[79]	1443	print "VERBOSE_1: Router detected $resol_arp{ipv4_address} - $resol_arp{mac_address}\n" if $verbose;
[2]	1444	}
	1445
	1446	ALL_ROUTER_IP_ADDRESS:
[13]	1447	for my $ip (Net::Netmask::sort_by_ip_address(keys %where)) { # '194.254.66.254')) {
[63]	1448
[13]	1449	next ALL_ROUTER_IP_ADDRESS if not exists $where{$ip}; # /a priori/ idiot car ne sers à rien...
[2]	1450
	1451	ALL_SWITCH_CONNECTED:
	1452	for my $switch_detected ( keys %{$where{$ip}} ) {
	1453
	1454	my $switch = $where{$ip}->{$switch_detected};
	1455
	1456	next ALL_SWITCH_CONNECTED if $switch->{port} eq '0';
[63]	1457
[2]	1458	$db_switch_output_port{$switch->{hostname}} = $switch->{port};
[79]	1459	print "VERBOSE_2: output port $switch->{hostname} : $switch->{port}\n" if $verbose;
[2]	1460	}
[63]	1461	}
[2]	1462
	1463	my %db_switch_link_with = ();
	1464
	1465	my @list_switch_ip = ();
	1466	my @list_switch_ipv4 = ();
[11]	1467	for my $sw (@SWITCH){
[2]	1468	push @list_switch_ip, $sw->{hostname};
	1469	}
	1470
[45]	1471	my $timestamp = time;
	1472
[2]	1473	ALL_SWITCH:
	1474	for my $one_computer (@list_switch_ip) {
[63]	1475	my %resol_arp = resolve_ip_arp_host($one_computer, q{*}, q{low}); # arp resolution
[2]	1476	next ALL_SWITCH if $resol_arp{mac_address} eq 'unknow';
[63]	1477
[2]	1478	push @list_switch_ipv4,$resol_arp{ipv4_address};
[63]	1479
[2]	1480	$where{$resol_arp{ipv4_address}} = find_all_switch_port($resol_arp{mac_address}); # find port on all switch
	1481
[80]	1482	if ($verbose) {
	1483	my @l = ();
	1484	for my $c ( keys %{$where{$resol_arp{ipv4_address}}} ) {
	1485	push @l, "$c -+ "; #$where{$resol_arp{ipv4_address}}->{$c}{hostname};
	1486	}
	1487	print "VERBOSE_3 $one_computer $resol_arp{ipv4_address} $resol_arp{mac_address} --- @l\n";
	1488	}
	1489
[2]	1490	$db_switch_ip_hostname{$resol_arp{ipv4_address}} = $resol_arp{hostname_fq};
[45]	1491
	1492	$SWITCH_DB{$one_computer}->{ipv4_address} = $resol_arp{ipv4_address};
	1493	$SWITCH_DB{$one_computer}->{mac_address} = $resol_arp{mac_address};
	1494	$SWITCH_DB{$one_computer}->{timestamp} = $timestamp;
[2]	1495	}
[63]	1496
[2]	1497	ALL_SWITCH_IP_ADDRESS:
	1498	for my $ip (Net::Netmask::sort_by_ip_address(@list_switch_ipv4)) {
[63]	1499
[2]	1500	next ALL_SWITCH_IP_ADDRESS if not exists $where{$ip};
	1501
	1502	DETECTED_SWITCH:
	1503	for my $switch_detected ( keys %{$where{$ip}} ) {
	1504
[79]	1505	next DETECTED_SWITCH if not exists $SWITCH_PORT_COUNT{ $db_switch_ip_hostname{$ip} };
[2]	1506
	1507	my $switch = $where{$ip}->{$switch_detected};
[68]	1508	#print "DEBUG1 : $db_switch_ip_hostname{$ip} / $switch->{hostname} : $switch->{port}\n" if $switch->{hostname} =~ m/sw3-batA0-3s/;
[2]	1509
	1510	next if $switch->{port} eq '0';
	1511	next if $switch->{port} eq $db_switch_output_port{$switch->{hostname}};
	1512	next if $switch->{hostname} eq $db_switch_ip_hostname{$ip}; # $computerdb->{$ip}{hostname};
	1513
	1514	$db_switch_link_with{ $db_switch_ip_hostname{$ip} } \|\|= {};
	1515	$db_switch_link_with{ $db_switch_ip_hostname{$ip} }->{ $switch->{hostname} } = $switch->{port};
[80]	1516	print "VERBOSE_4: $db_switch_ip_hostname{$ip} -> $switch->{hostname} : $switch->{port}\n" if $verbose;
[2]	1517	}
	1518
	1519	}
[63]	1520
[2]	1521	my %db_switch_connected_on_port = ();
	1522	my $maybe_more_than_one_switch_connected = 'yes';
[63]	1523
[2]	1524	while ($maybe_more_than_one_switch_connected eq 'yes') {
	1525	for my $sw (keys %db_switch_link_with) {
	1526	for my $connect (keys %{$db_switch_link_with{$sw}}) {
[63]	1527
[2]	1528	my $port = $db_switch_link_with{$sw}->{$connect};
[63]	1529
[2]	1530	$db_switch_connected_on_port{"$connect:$port"} \|\|= {};
	1531	$db_switch_connected_on_port{"$connect:$port"}->{$sw}++; # Just to define the key
	1532	}
	1533	}
	1534
	1535	$maybe_more_than_one_switch_connected = 'no';
	1536
	1537	SWITCH_AND_PORT:
	1538	for my $swport (keys %db_switch_connected_on_port) {
[63]	1539
[2]	1540	next if keys %{$db_switch_connected_on_port{$swport}} == 1;
[63]	1541
[2]	1542	$maybe_more_than_one_switch_connected = 'yes';
	1543
[63]	1544	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1545	my @sw_on_same_port = keys %{$db_switch_connected_on_port{$swport}};
	1546
	1547	CONNECTED:
	1548	for my $sw_connected (@sw_on_same_port) {
[63]	1549
[2]	1550	next CONNECTED if not keys %{$db_switch_link_with{$sw_connected}} == 1;
[63]	1551
[2]	1552	$db_switch_connected_on_port{$swport} = {$sw_connected => 1};
[63]	1553
[2]	1554	for my $other_sw (@sw_on_same_port) {
	1555	next if $other_sw eq $sw_connected;
[63]	1556
[2]	1557	delete $db_switch_link_with{$other_sw}->{$sw_connect};
	1558	}
[63]	1559
[2]	1560	# We can not do better for this switch for this loop
	1561	next SWITCH_AND_PORT;
	1562	}
	1563	}
	1564	}
	1565
	1566	my %db_switch_parent =();
	1567
	1568	for my $sw (keys %db_switch_link_with) {
	1569	for my $connect (keys %{$db_switch_link_with{$sw}}) {
[63]	1570
[2]	1571	my $port = $db_switch_link_with{$sw}->{$connect};
[63]	1572
[2]	1573	$db_switch_connected_on_port{"$connect:$port"} \|\|= {};
	1574	$db_switch_connected_on_port{"$connect:$port"}->{$sw} = $port;
[63]	1575
[2]	1576	$db_switch_parent{$sw} = {switch => $connect, port => $port};
	1577	}
	1578	}
	1579
[63]	1580	print "Switch output port and parent port connection\n";
[2]	1581	print "---------------------------------------------\n";
	1582	for my $sw (sort keys %db_switch_output_port) {
	1583	if (exists $db_switch_parent{$sw}) {
[78]	1584	printf "%-27s %2s +--> %2s %-25s\n", $sw, $db_switch_output_port{$sw}, $db_switch_parent{$sw}->{port}, $db_switch_parent{$sw}->{switch};
[2]	1585	}
	1586	else {
[78]	1587	printf "%-27s %2s +--> router\n", $sw, $db_switch_output_port{$sw};
[2]	1588	}
	1589	}
	1590	print "\n";
	1591
	1592	print "Switch parent and children port inter-connection\n";
	1593	print "------------------------------------------------\n";
[63]	1594	for my $swport (sort keys %db_switch_connected_on_port) {
	1595	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1596	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1597	if (exists $db_switch_output_port{$sw}) {
[78]	1598	printf "%-27s %2s <--+ %2s %-25s\n", $sw_connect, $port_connect, $db_switch_output_port{$sw}, $sw;
[2]	1599	}
	1600	else {
[78]	1601	printf "%-27s %2s <--+ %-25s\n", $sw_connect, $port_connect, $sw;
[2]	1602	}
	1603	}
	1604	}
	1605
	1606	my $switch_connection = {
	1607	output_port => \%db_switch_output_port,
	1608	parent => \%db_switch_parent,
	1609	connected_on_port => \%db_switch_connected_on_port,
	1610	link_with => \%db_switch_link_with,
[25]	1611	switch_db => \%SWITCH_DB,
[2]	1612	};
[63]	1613
[44]	1614	YAML::Syck::DumpFile("$KLASK_SW_FILE", $switch_connection);
[63]	1615	return;
[2]	1616	}
	1617
[4]	1618	sub cmd_exportsw {
	1619	my @ARGV = @_;
[2]	1620
[34]	1621	test_switchdb_environnement();
	1622
[4]	1623	my $format = 'txt';
	1624
	1625	my $ret = GetOptions(
	1626	'format\|f=s' => \$format,
	1627	);
	1628
	1629	my %possible_format = (
	1630	txt => \&cmd_exportsw_txt,
	1631	dot => \&cmd_exportsw_dot,
	1632	);
	1633
	1634	$format = 'txt' if not defined $possible_format{$format};
[63]	1635
[4]	1636	$possible_format{$format}->(@ARGV);
[63]	1637	return;
[4]	1638	}
	1639
	1640	sub cmd_exportsw_txt {
	1641
[44]	1642	my $switch_connection = YAML::Syck::LoadFile("$KLASK_SW_FILE");
[4]	1643
	1644	my %db_switch_output_port = %{$switch_connection->{output_port}};
	1645	my %db_switch_parent = %{$switch_connection->{parent}};
	1646	my %db_switch_connected_on_port = %{$switch_connection->{connected_on_port}};
	1647
[63]	1648	print "Switch output port and parent port connection\n";
[4]	1649	print "---------------------------------------------\n";
	1650	for my $sw (sort keys %db_switch_output_port) {
	1651	if (exists $db_switch_parent{$sw}) {
[78]	1652	printf "%-27s %2s +--> %2s %-25s\n", $sw, $db_switch_output_port{$sw}, $db_switch_parent{$sw}->{port}, $db_switch_parent{$sw}->{switch};
[4]	1653	}
	1654	else {
[78]	1655	printf "%-27s %2s +--> router\n", $sw, $db_switch_output_port{$sw};
[4]	1656	}
	1657	}
	1658	print "\n";
	1659
	1660	print "Switch parent and children port inter-connection\n";
	1661	print "------------------------------------------------\n";
[63]	1662	for my $swport (sort keys %db_switch_connected_on_port) {
	1663	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[4]	1664	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1665	if (exists $db_switch_output_port{$sw}) {
[78]	1666	printf "%-27s %2s <--+ %2s %-25s\n", $sw_connect, $port_connect, $db_switch_output_port{$sw}, $sw;
[4]	1667	}
	1668	else {
[78]	1669	printf "%-27s %2s <--+ %-25s\n", $sw_connect, $port_connect, $sw;
[4]	1670	}
	1671	}
	1672	}
[63]	1673	return;
[4]	1674	}
	1675
	1676	sub cmd_exportsw_dot {
	1677
[44]	1678	my $switch_connection = YAML::Syck::LoadFile("$KLASK_SW_FILE");
[63]	1679
[2]	1680	my %db_switch_output_port = %{$switch_connection->{output_port}};
	1681	my %db_switch_parent = %{$switch_connection->{parent}};
	1682	my %db_switch_connected_on_port = %{$switch_connection->{connected_on_port}};
	1683	my %db_switch_link_with = %{$switch_connection->{link_with}};
[25]	1684	my %db_switch_global = %{$switch_connection->{switch_db}};
	1685
[2]	1686	my %db_building= ();
[11]	1687	for my $sw (@SWITCH) {
[63]	1688	my ($building, $location) = split m/ \/ /xms, $sw->{location}, 2;
[2]	1689	$db_building{$building} \|\|= {};
	1690	$db_building{$building}->{$location} \|\|= {};
	1691	$db_building{$building}->{$location}{ $sw->{hostname} } = 'y';
	1692	}
[63]	1693
	1694
[2]	1695	print "digraph G {\n";
	1696
[4]	1697	print "site [label = \"site\", color = black, fillcolor = gold, shape = invhouse, style = filled];\n";
	1698	print "internet [label = \"internet\", color = black, fillcolor = cyan, shape = house, style = filled];\n";
[2]	1699
	1700	my $b=0;
	1701	for my $building (keys %db_building) {
	1702	$b++;
[63]	1703
[4]	1704	print "\"building$b\" [label = \"$building\", color = black, fillcolor = gold, style = filled];\n";
	1705	print "site -> \"building$b\" [len = 2, color = firebrick];\n";
[2]	1706
	1707	my $l = 0;
	1708	for my $loc (keys %{$db_building{$building}}) {
	1709	$l++;
[63]	1710
	1711	print "\"location$b-$l\" [label = \"$building" . q{/} . join(q{\n}, split(m{ / }xms, $loc)) . "\", color = black, fillcolor = orange, style = filled];\n";
[33]	1712	# print "\"location$b-$l\" [label = \"$building / $loc\", color = black, fillcolor = orange, style = filled];\n";
[4]	1713	print "\"building$b\" -> \"location$b-$l\" [len = 2, color = firebrick]\n";
[2]	1714
	1715	for my $sw (keys %{$db_building{$building}->{$loc}}) {
	1716
	1717	print "\"$sw:$db_switch_output_port{$sw}\" [label = $db_switch_output_port{$sw}, color = black, fillcolor = lightblue, peripheries = 2, style = filled];\n";
	1718
[25]	1719	my $swname = $sw;
[63]	1720	$swname .= q{\n-\n} . "$db_switch_global{$sw}->{model}" if exists $db_switch_global{$sw} and exists $db_switch_global{$sw}->{model};
[25]	1721	print "\"$sw\" [label = \"$swname\", color = black, fillcolor = palegreen, shape = rect, style = filled];\n";
[4]	1722	print "\"location$b-$l\" -> \"$sw\" [len = 2, color = firebrick, arrowtail = dot]\n";
	1723	print "\"$sw\" -> \"$sw:$db_switch_output_port{$sw}\" [len=2, style=bold, arrowhead = normal, arrowtail = invdot]\n";
[2]	1724
	1725
	1726	for my $swport (keys %db_switch_connected_on_port) {
[63]	1727	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1728	next if not $sw_connect eq $sw;
	1729	next if $port_connect eq $db_switch_output_port{$sw};
	1730	print "\"$sw:$port_connect\" [label = $port_connect, color = black, fillcolor = plum, peripheries = 1, style = filled];\n";
[4]	1731	print "\"$sw:$port_connect\" -> \"$sw\" [len=2, style=bold, arrowhead= normal, arrowtail = inv]\n";
[2]	1732	}
	1733	}
	1734	}
	1735	}
	1736
[63]	1737	# print "Switch output port and parent port connection\n";
[2]	1738	# print "---------------------------------------------\n";
	1739	for my $sw (sort keys %db_switch_output_port) {
	1740	if (exists $db_switch_parent{$sw}) {
	1741	# printf " \"%s:%s\" -> \"%s:%s\"\n", $sw, $db_switch_output_port{$sw}, $db_switch_parent{$sw}->{switch}, $db_switch_parent{$sw}->{port};
	1742	}
	1743	else {
	1744	printf " \"%s:%s\" -> internet\n", $sw, $db_switch_output_port{$sw};
	1745	}
	1746	}
	1747	print "\n";
	1748
	1749	# print "Switch parent and children port inter-connection\n";
	1750	# print "------------------------------------------------\n";
[63]	1751	for my $swport (sort keys %db_switch_connected_on_port) {
	1752	my ($sw_connect,$port_connect) = split m/ : /xms, $swport;
[2]	1753	for my $sw (keys %{$db_switch_connected_on_port{$swport}}) {
	1754	if (exists $db_switch_output_port{$sw}) {
	1755	printf " \"%s:%s\" -> \"%s:%s\" [color = navyblue]\n", $sw, $db_switch_output_port{$sw}, $sw_connect, $port_connect;
	1756	}
	1757	else {
	1758	printf " \"%s\" -> \"%s%s\"\n", $sw, $sw_connect, $port_connect;
	1759	}
	1760	}
	1761	}
	1762
	1763	print "}\n";
[63]	1764	return;
[2]	1765	}
	1766
	1767
	1768	__END__
	1769
	1770	=head1 NAME
	1771
	1772	klask - ports manager and finder for switch
	1773
	1774
[63]	1775	=head1 USAGE
[2]	1776
	1777	klask updatedb
[45]	1778	klask exportdb --format [txt\|html]
[76]	1779	klask removedb computer*
[75]	1780	klask cleandb --day number_of_day --verbose
[2]	1781
[5]	1782	klask updatesw
	1783	klask exportsw --format [txt\|dot]
	1784
[2]	1785	klask searchdb computer
	1786	klask search computer
[69]	1787	klask search-mac-on-switch switch mac_addr
[2]	1788
[76]	1789	klask ip-free --day number_of_day --format [txt\|html] [vlan_name]
[69]	1790
[2]	1791	klask enable switch port
	1792	klask disable swith port
	1793	klask status swith port
	1794
	1795
	1796	=head1 DESCRIPTION
	1797
[6]	1798	klask is a small tool to find where is a host in a big network. klask mean search in brittany.
[2]	1799
[6]	1800	Klask has now a web site dedicated for it !
[2]	1801
[6]	1802	http://servforge.legi.inpg.fr/projects/klask
	1803
	1804
[2]	1805	=head1 COMMANDS
	1806
	1807
	1808	=head2 search
	1809
	1810	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.
	1811
	1812
	1813	=head2 enable
	1814
	1815	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.
	1816
	1817
	1818	=head2 disable
	1819
	1820	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.
	1821
	1822
	1823	=head2 status
	1824
	1825	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.
	1826
	1827
	1828	=head2 updatedb
	1829
	1830	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.
	1831
	1832
	1833	=head2 exportdb
	1834
	1835	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...
	1836
	1837
[5]	1838	=head2 updatesw
	1839
	1840	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.
	1841
	1842
	1843	=head2 exportsw --format [txt\|dot]
	1844
	1845	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.
	1846
	1847	klask exportsw --format dot > /tmp/map.dot
	1848	dot -Tpng /tmp/map.dot > /tmp/map.png
	1849
	1850
	1851
[2]	1852	=head1 CONFIGURATION
	1853
	1854	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 !
	1855
	1856	Here an example, be aware with indent, it's important in YAML, do not use tabulation !
	1857
	1858	default:
	1859	community: public
	1860	snmpport: 161
	1861
	1862	network:
[5]	1863	labnet:
	1864	ip-subnet:
	1865	- add: 192.168.1.0/24
	1866	- add: 192.168.2.0/24
	1867	interface: eth0
	1868	main-router: gw1.labnet.local
[2]	1869
[5]	1870	schoolnet:
	1871	ip-subnet:
	1872	- add: 192.168.6.0/24
	1873	- add: 192.168.7.0/24
	1874	interface: eth0.38
	1875	main-router: gw2.schoolnet.local
	1876
[2]	1877	switch:
	1878	- hostname: sw1.klask.local
	1879	portignore:
	1880	- 1
	1881	- 2
	1882
	1883	- hostname: sw2.klask.local
[5]	1884	location: BatK / 2 / K203
	1885	type: HP2424
[2]	1886	portignore:
	1887	- 1
	1888	- 2
	1889
	1890	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.
	1891
	1892
	1893	=head1 FILES
	1894
	1895	/etc/klask.conf
	1896	/var/cache/klask/klaskdb
[7]	1897	/var/cache/klask/switchdb
[2]	1898
	1899	=head1 SEE ALSO
	1900
	1901	Net::SNMP, Net::Netmask, Net::CIDR::Lite, NetAddr::IP, YAML
	1902
	1903
	1904	=head1 VERSION
	1905
[36]	1906	$Id: klask 80 2011-03-29 15:57:13Z g7moreau $
[2]	1907
	1908
	1909	=head1 AUTHOR
	1910
[5]	1911	Written by Gabriel Moreau, Grenoble - France
[2]	1912
	1913
[63]	1914	=head1 LICENSE AND COPYRIGHT
[2]	1915
	1916	GPL version 2 or later and Perl equivalent
[45]	1917
[63]	1918	Copyright (C) 2005-2009 Gabriel Moreau.

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

Download in other formats: