# This module contains the code used by the snmpInfo CGI script to produce its
# output in the form of HTML lists.

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub get {
	local($v) = shift;
	local($c,$p,$t,$x);
	print "<br>#get	v=\"$v\" instance=(@_)\n" if $D>2;
	if ($t = $mib{$v}) {
		if ($t eq 'g' || $t eq 't' || $t eq 'e') {
			$c = "&$v()";
			print "<br>#get	Group c=\"$c\"\n" if $D>2;
			$x = eval($c);
			print "<br>$v.@_\t$x\n" if $D>2;
		} elsif ($t eq 'v') {
			$c = "&$v(@_)";
			print "<br>#get	Variable c=\"$c\"\n" if $D>2;
			$x = eval($c);
			print "<br>#get	x=$x\n" if $D>2;
		} elsif ($t eq 'sv') {
			($p = $v) =~ s/[A-Z].*//;
			print "<br>#get	Simple var p=\"$p\"\n" if $D>2;
			$x = &vvar($p,$v);
			print "<br>#get	x=$x\n" if $D>2;
		} elsif ($t eq 'vv') {
			($p = $v) =~ s/[A-Z].*//;
			print "<br>#get	Vector var p=\"$p\"\n" if $D>2;
			$x = &vvar($p,$v,@_);
			print "<br>#get	x=$x\n" if $D>2;
		} else {
			print "<br>#get	t=$t unknown for v=\"$v\"\n" if $D>2;
		}
	}
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub snmp {
	&system;
	&interfaces;
	&at;
	&ip;
	&icmp;
	&tcp;
	&udp;
	&egp;
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub system { # group.
	print "${G1}system${G2}\n";
	print "<dl>\n";
	&sysDescr;
	&sysObjectID;
	&sysUpTime;
	&sysContact;
	&sysName;
	&sysLocation;
	&sysServices;
	print "</dl><!-- system -->\n";
}

sub sysDescr {
	print "<br>#sysDescr args=(@_)\n" if $D>2;
	local($d);
	if ($d = `uname -a`) {
		print "<br>#sysDescr uname -a gave $d" if $D>2;
	} elsif ($d = `hostname`) {
		print "<br>#sysDescr hostname gave $d" if $D>2;
	} else {
		$d = 'localhost';
	}
	$d =~ s/\s+$//;
	print "<dt>sysDescr<dd>$d\n";
}

sub sysUpTime {
	local($t,$x);
	if (($t = `uptime`) && (($d,$h,$m) = ($t =~ /(\d+) days,*\s*(\d+):(\d+)/))) {
		$x = (((($d * 24) + $h) * 60) + $m) * 60 * 100;
	}
	print "<dt>sysUpTime<dd>$x (${d}d${h}h${m}m)\n";
}

sub sysContact {
	local($x) = &html(`cat sysContact`);
	print "<dt>sysContact<dd>$x\n";
}

sub sysLocation {
	local($x) = &html(`cat sysLocation`);
	print "<dt>sysLocation<dd>$x\n";
}

sub sysName {
	$sysName = &getname() unless $sysName;
	print "<dt>sysName<dd>$sysName\n";
}

sub sysObjectID { print "<dt>sysObjectID<dd>snmp.html\n"; }
sub sysServices { print "<dt>sysServices<dd>128\n"; }

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub df { # group.
	print "${G1}df${G2}\n";
	print "<dl>\n";
	&dftbl() unless defined $dfNumber;
	&dfNumber();
	&dfTable();
	print "</dl><!-- df -->\n";
}

sub dfNumber {
	&dftbl() unless defined $dfNumber;
	print "<dt>dfNumber<dd>$dfNumber\n";
}

sub dfTable { # dl.
	local($i);
	print "<dt>dfTable<dd>\n";
	print "<dl>\n";
	&dftbl() unless $dfNumber;
	for ($i=1; $i <= $dfNumber; $i++) {
		print "<br>#dfTable	i=$i.\n" if $D>2;
		&dfEntry($i);
	}
	print "</dl><!-- dfTable -->\n";
}

sub dfEntry { # entry.
	local($i) = @_;
	print "<dt>dfEntry $i<dd>\n";
	print "<dl>\n";
	&vvar('df','dfIndex',$i);
	&vvar('df','dfPartition',$i);
	&vvar('df','dfTotalKB',$i);
	&vvar('df','dfUsedKB',$i);
	&vvar('df','dfFreeKB',$i);
	&vvar('df','dfFreePct',$i);
	&vvar('df','dfDirectory',$i);
	print "</dl><!-- dfEntry $i -->\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
# Here's an implementation of a "user" dl.  We deliver the info  from  the
# passwd file as an SNMP dl.  We suppress the encrypted password field, of
# course.  The rest of the info should generally be innocuous.  Perhaps we can
# also add some info returned by finger.
sub usr { # group.
	print "${G1}usr${G2}\n";
	print "<dl>\n";
	&usrtbl() unless defined $usrNumber;
	&usrNumber();
	&usrTable();
	print "</dl><!-- usr -->\n";
}

sub usrNumber {
	&usrtbl() unless defined $usrNumber;
	print "<dt>usrNumber<dd>$usrNumber\n";
}

sub usrTable { # dl.
	local($i);
	print "<dt>usrTable<dd>\n";
	print "<dl>\n";
	&usrtbl() unless $usrNumber;
	for ($i=1; $i <= $usrNumber; $i++) {
		print "<br>#usrTable	i=$i.\n" if $D>2;
		&usrEntry($i);
	}
	print "</dl><!-- usrTable -->\n";
}

sub usrEntry { # entry.
	local($i) = @_;
#	local($u);
#	&vvar('usr','usrUid',$u);
#	return if $u < 10;
	print "<dt>usrEntry $i<dd>\n";
	print "<dl>\n";
	&vvar('usr','usrIndex',$i);
	&vvar('usr','usrName',$i);
	&vvar('usr','usrUid',$i);
	&vvar('usr','usrGid',$i);
	&vvar('usr','usrDescr',$i);
	&vvar('usr','usrHome',$i);
	&vvar('usr','usrShell',$i);
	&vvar('usr','usrPlan',$i);
	print "</dl><!-- usrEntry $i -->\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
# Here's a  general-purpose  routine  to  produce  the  html  output  for  an
# associative array variable.
sub avar {
	local($p,$v,$i) = @_;
	local($f);
	$i = 1 unless $i;
	if ($f = $get{$p}) {eval("&$f") unless $cnt{$p}}
	print "<dt>$v.$i<dd>" . eval("\$${v}{$i}") . "\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
# Here's a general-purpose routine to produce the html output  for  a  simple
# variable.
sub svar {
	local($p,$v) = @_;
	local($f,$x);
	if ($f = $get{$p}) {eval("&$f") unless $cnt{$p}}
	if (defined($V{$v})) {
		$x = $V{$v};
	} else {
		$x = eval("\$${v}");
	}
	print "<dt>$v<dd>$x\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
# Here's a general-purpose routine to produce the html output for a  variable
# that has a single index.
sub vvar {
	local($p,$v,$i) = @_;
	local($f);
	$i = 1 unless $i;
	if ($f = $get{$p}) {eval("&$f") unless $cnt{$p}}
	print "<dt>$v.$i" if $fmt eq 'L';
#	print "<dd>$$v[$i]\n";		# Doesn't work witn perl4.
#	print "<dd>${$v}[$i]\n";	# Doesn't work witn perl4.
	print "<dd>" . eval("\$${v}[$i]") . "\n";	# Klunky, but works.
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub if {&interfaces};

sub interfaces { # group.
	print "<dt>interfaces:\n";
	print "<dl>\n";
	&iftbl() unless defined $ifNumber;
	&svar('if','ifNumber');
	&ifTable();
	print "</dl><!-- interfaces -->\n";
}

sub ifTable { # dl.
	local($i);
	print "<dt>ifTable:<dd>\n";
	print "<dl>\n";
	&iftbl() unless $ifNumber;
	for ($i=1; $i <= $ifNumber; $i++) {
		print "<dd>#ifTable	i=$i.\n" if $D>2;
		&ifEntry($i);
	}
	print "</dl><!-- ifTable -->\n";
}

sub th {for (@_) {print "<th>$_\n"}}
sub td {for (@_) {print "<td>$_\n"}}

sub ifEntry { # entry.
	local($i) = @_;
	print "<dt>ifEntry $i:<dd>\n";
	print "<dl>\n";
	&vvar('if','ifIndex',$i);
	&vvar('if','ifDescr',$i);
	&vvar('if','ifType',$i);
	&vvar('if','ifMtu',$i);
	&vvar('if','ifSpeed',$i);
	&vvar('if','ifPhysAddress',$i);
	&vvar('if','ifAdminStat',$i);
	&vvar('if','ifOperStat',$i);
	&vvar('if','ifLastChange',$i);
	&vvar('if','ifInOctets',$i);
	&vvar('if','ifInUcastPkts',$i);
	&vvar('if','ifInNUcastPkts',$i);
	&vvar('if','ifInDiscards',$i);
	&vvar('if','ifInErrors',$i);
	&vvar('if','ifInUnknownProtos',$i);
	&vvar('if','ifOutOctets',$i);
	&vvar('if','ifOutUcastPkts',$i);
	&vvar('if','ifOutNUcastPkts',$i);
	&vvar('if','ifOutDiscards',$i);
	&vvar('if','ifOutErrors',$i);
	&vvar('if','ifOutQLen',$i);
	print "</dl><!-- ifEntry $i -->\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub at { # group.
	print "${G1}at${G2}\n";
	print "<dl>\n";
	&atTable();
	print "</dl><!-- at -->\n";
}

sub atTable { # dl.
	local($i);
	print "<dt>atTable<dd>\n";
	print "<dl>\n";
	&iftbl() unless $ifNumber;
	for ($i=1; $i <= $ifNumber; $i++) {
		print "<br>#atTable	i=$i.\n" if $D>2;
		&atEntry($i);
	}
	print "</dl><!-- atTable -->\n";
}

sub atEntry { # entry.
	local($i) = @_;
	print "<dt>atEntry $i<dd>\n";
	print "<dl>\n";
	&atIfIndex($i);
	&atPhysAddress($i);
	&atNetAddress($i);
	print "</dl><!-- atEntry $i -->\n";
}

sub atIfIndex {
	local($i) = $_[0] || 1;
	&attbl() unless $atNumber;
	print "<dt>atIfIndex.$i<dd>" . $atIfIndex{$i} . "\n";
}

sub atPhysAddress {
	local($i) = $_[0] || 1;
	&attbl() unless $atNumber;
	print "<dt>atPhysAddress.$i<dd>" . $atPhysAddress{$i} . "\n";
}

sub atNetAddress {
	local($i) = $_[0] || 1;
	&attbl() unless $atNumber;
	print "<dt>atNetAddress.$i<dd>" . $atNetAddress{$i} . "\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub ip { # group.
	print "${G1}ip${G2}\n";
	print "<dl>\n";
	&svar('ip','ipForwarding');
	&svar('ip','ipDefaultTTL');
	&svar('ip','ipInReceives');
	&svar('ip','ipInHdrErrors');
	&svar('ip','ipInAddrErrors');
	&svar('ip','ipForwDatagrams');
	&svar('ip','ipInUnknownProtos');
	&svar('ip','ipInDiscards');
	&svar('ip','ipInDelivers');
	&svar('ip','ipOutRequests');
	&svar('ip','ipOutDiscards');
	&svar('ip','ipOutNoRoutes');
	&svar('ip','ipReasmTimeout');
	&svar('ip','ipReasmRecords');
	&svar('ip','ipReasmOKs');
	&svar('ip','ipReasmFails');
	&svar('ip','ipFragOKs');
	&svar('ip','ipFragFails');
	&svar('ip','ipFragCreates');
	&svar('ip','ipAddrs');
	&ipAddrTable();
	&svar('ip','ipRoutes');
	&ipRoutingTable();
	print "</dl><!-- ip -->\n";
}

sub ipInReceives {
	&iftbl() unless $ifNumber;
	print "<dt>ipInReceives<dd>$ipInReceives\n";
}

sub ipOutRequests {
	&iftbl() unless $ifNumber;
	print "<dt>ipOutRequests<dd>$ipOutRequests\n";
}

#sub ipForwarding {print "<dt>ipForwarding<dd>$ipForwarding\n"}
#sub ipDefaultTTL {print "<dt>ipDefaultTTL<dd>$ipDefaultTTL\n"}
#sub ipInHdrErrors {print "<dt>ipInHdrErrors<dd>$ipInHdrErrors\n"}
#sub ipInAddrErrors {print "<dt>ipInAddrErrors<dd>$ipInAddrErrors\n"}
#sub ipForwDatagrams {print "<dt>ipForwDatagrams<dd>$ipForwDatagrams\n"}
#sub ipInUnknownProtos {print "<dt>ipInUnknownProtos<dd>$ipInUnknownProtos\n"}
#sub ipInDiscards {print "<dt>ipInDiscards<dd>$ipInDiscards\n"}
#sub ipInDelivers {print "<dt>ipInDelivers<dd>$ipInDelivers\n"}
#sub ipOutDiscards {print "<dt>ipOutDiscards<dd>$ipOutDiscards\n"}
#sub ipOutNoRoutes {print "<dt>ipOutNoRoutes<dd>$ipOutNoRoutes\n"}
#sub ipReasmTimeout {print "<dt>ipReasmTimeout<dd>$ipReasmTimeout\n"}
#sub ipReasmRecords {print "<dt>ipReasmRecords<dd>$ipReasmRecords\n"}
#sub ipReasmOKs {print "<dt>ipReasmOKs<dd>$ipReasmOKs\n"}
#sub ipReasmFails {print "<dt>ipReasmFails<dd>$ipReasmFails\n"}
#sub ipFragOKs {print "<dt>ipFragOKs<dd>$ipFragOKs\n"}
#sub ipFragFails {print "<dt>ipFragFails<dd>$ipFragFails\n"}
#sub ipFragCreates {print "<dt>ipFragCreates<dd>$ipFragCreates\n"}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub ipAddr { # group.
	print "<dt>ipAddr<dd>\n";
	print "<dl>\n";
	&ipAddrTable();
	print "</dl><!-- ipAddr -->\n";
}

sub ipAddrTable { # group.
	print "<dt>ipAddrTable<dd>\n";
	print "<dl>\n";
	&ipadtbl() unless %ipAdEntAddr;
	print "<dt>#ipAddrTable entries<dd>\n" if $D>2;
	for $a (sort oidorder keys(%ipAdEntAddr)) {
		&ipAddrEntry($a);
	}
	print "</dl><!-- ipAddrTable -->\n";
}

sub ipAddrEntry { # entry.
	local($i) = @_;
	print "<dt>ipAddrEntry $i<dd>\n";
	print "<dl>\n";
	&ipAdEntAddr($i);
	&ipAdEntIfIndex($i);
	&ipAdEntNetMask($i);
	&ipAdEntBcastAddr($i);
	print "</dl><!-- ipAddrEntry $i -->\n";
}

sub ipAdEntAddr {local($a) = @_; print "<dt>ipAdEntAddr<dd>$ipAdEntAddr{$a}\n"}
sub ipAdEntIfIndex {local($a) = @_; print "<dt>ipAdEntIfIndex<dd>$ipAdEntIfIndex{$a}\n"}
sub ipAdEntNetMask {local($a) = @_; print "<dt>ipAdEntNetMask<dd>$ipAdEntNetMask{$a}\n"}
sub ipAdEntBcastAddr {local($a) = @_; print "<dt>ipAdEntBcastAddr<dd>$ipAdEntBcastAddr{$a}\n"}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub ipRoutingTable { # group.
	print "<dt>ipRoutingTable<dd>\n";
	print "<dl>\n";
	&rttbl() unless $ipRoutes;
	print "<dt>#ipRoutingTable $ipRoutes entries<dd>\n" if $D>2;
	for $a (sort oidorder keys(%ipRouteDest)) {
		&ipRouteEntry($a);
	}
	print "</dl><!-- ipRoutingTable -->\n";
}

sub ipRouteEntry { # entry.
	local($x) = @_;
	print "<dt>ipRouteEntry $x<dd>\n";
	print "<dl>\n";
	&ipRouteDest($x);
	&ipRouteIfIndex($x);
	&ipRouteMetric1($x);
	&ipRouteMetric2($x);
	&ipRouteMetric3($x);
	&ipRouteMetric4($x);
	&ipRouteNextHop($x);
	&ipRouteType($x);
	&ipRouteProto($x);
	&ipRouteAge($x);
	print "</dl><!-- ipRouteEntry $x -->\n";
}

sub ipRouteDest {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteDest.$a<dd>" . $ipRouteDest{$a} . "\n";
}

sub ipRouteIfIndex {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteIfIndex.$a<dd>" . $ipRouteIfIndex{$a} . "\n";
}

sub ipRouteMetric1 {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteMetric1.$a<dd>" . $ipRouteMetric1{$a} . "\n";
}

sub ipRouteMetric2 {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteMetric2.$a<dd>" . $ipRouteMetric2{$a} . "\n";
}

sub ipRouteMetric3 {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteMetric3.$a<dd>" . $ipRouteMetric3{$a} . "\n";
}

sub ipRouteMetric4 {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteMetric4.$a<dd>" . $ipRouteMetric4{$a} . "\n";
}

sub ipRouteNextHop {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteNextHop.$a<dd>" . $ipRouteNextHop{$a} . "\n";
}

sub ipRouteType {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteType.$a<dd>" . $ipRouteType{$a} . "\n";
}

sub ipRouteProto {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteProto.$a<dd>" . $ipRouteProto{$a} . "\n";
}

sub ipRouteAge {
	local($a) = @_;
	&rttbl() unless $ipRoutes;
	print "<dt>ipRouteAge.$a<dd>" . $ipRouteAge{$a} . "\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub icmp { # group.
	print "${G1}icmp${G2}\n";
	print "<dl>\n";
	&icmpOutAddrMaskReps();
	&icmpOutAddrMasks();
	&icmpOutTimestampReps();
	&icmpOutTimestamps();
	&icmpOutEchoReps();
	&icmpOutEchos();
	&icmpOutRedirects();
	&icmpOutSrcQuenchs();
	&icmpOutParmProbs();
	&icmpOutTimeExcds();
	&icmpOutDestUnreachs();
	&icmpOutErrors();
	&icmpOutMsgs();
	&icmpInAddrMaskReps();
	&icmpInAddrMasks();
	&icmpInTimestampReps();
	&icmpInTimestamps();
	&icmpInEchoReps();
	&icmpInEchos();
	&icmpInRedirects();
	&icmpInSrcQuenchs();
	&icmpInParmProbs();
	&icmpInTimeExcds();
	&icmpInDestUnreachs();
	&icmpInErrors();
	&icmpInMsgs();
	print "</dl><!-- icmp -->\n";
}

sub icmpInMsgs {print "<dt>icmpInMsgs<dd>$icmpInMsgs\n"}
sub icmpInErrors {print "<dt>icmpInErrors<dd>$icmpInErrors\n"}
sub icmpInDestUnreachs {print "<dt>icmpInDestUnreachs<dd>$icmpInDestUnreachs\n"}
sub icmpInTimeExcds {print "<dt>icmpInTimeExcds<dd>$icmpInTimeExcds\n"}
sub icmpInParmProbs {print "<dt>icmpInParmProbs<dd>$icmpInParmProbs\n"}
sub icmpInSrcQuenchs {print "<dt>icmpInSrcQuenchs<dd>$icmpInSrcQuenchs\n"}
sub icmpInRedirects {print "<dt>icmpInRedirects<dd>$icmpInRedirects\n"}
sub icmpInEchos {print "<dt>icmpInEchos<dd>$icmpInEchos\n"}
sub icmpInEchoReps {print "<dt>icmpInEchoReps<dd>$icmpInEchoReps\n"}
sub icmpInTimestamps {print "<dt>icmpInTimestamps<dd>$icmpInTimestamps\n"}
sub icmpInTimestampReps {print "<dt>icmpInTimestampReps<dd>$icmpInTimestampReps\n"}
sub icmpInAddrMasks {print "<dt>icmpInAddrMasks<dd>$icmpInAddrMasks\n"}
sub icmpInAddrMaskReps {print "<dt>icmpInAddrMaskReps<dd>$icmpInAddrMaskReps\n"}
sub icmpOutMsgs {print "<dt>icmpOutMsgs<dd>$icmpOutMsgs\n"}
sub icmpOutErrors {print "<dt>icmpOutErrors<dd>$icmpOutErrors\n"}
sub icmpOutDestUnreachs {print "<dt>icmpOutDestUnreachs<dd>$icmpOutDestUnreachs\n"}
sub icmpOutTimeExcds {print "<dt>icmpOutTimeExcds<dd>$icmpOutTimeExcds\n"}
sub icmpOutParmProbs {print "<dt>icmpOutParmProbs<dd>$icmpOutParmProbs\n"}
sub icmpOutSrcQuenchs {print "<dt>icmpOutSrcQuenchs<dd>$icmpOutSrcQuenchs\n"}
sub icmpOutRedirects {print "<dt>icmpOutRedirects<dd>$icmpOutRedirects\n"}
sub icmpOutEchos {print "<dt>icmpOutEchos<dd>$icmpOutEchos\n"}
sub icmpOutEchoReps {print "<dt>icmpOutEchoReps<dd>$icmpOutEchoReps\n"}
sub icmpOutTimestamps {print "<dt>icmpOutTimestamps<dd>$icmpOutTimestamps\n"}
sub icmpOutTimestampReps {print "<dt>icmpOutTimestampReps<dd>$icmpOutTimestampReps\n"}
sub icmpOutAddrMasks {print "<dt>icmpOutAddrMasks<dd>$icmpOutAddrMasks\n"}
sub icmpOutAddrMaskReps {print "<dt>icmpOutAddrMaskReps<dd>$icmpOutAddrMaskReps\n"}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub tcp { # group.
	print "${G1}tcp${G2}\n";
	print "<dl>\n";
	&tcpRtoAlgorithm();
	&tcpRtoMin();
	&tcpRtoMax();
	&tcpMaxConn();
	&tcpActiveOpens();
	&tcpPassiveOpens();
	&tcpAttemptFails();
	&tcpEstabResets();
	&tcpCurrEstab();
	&tcpInSegs();
	&tcpOutSegs();
	&tcpRetransSegs();
	&tcpConnTable();
	print "</dl><!-- tcp -->\n";
}

sub tcpRtoAlgorithm {print "<dt>tcpRtoAlgorithm<dd>$tcpRtoAlgorithm\n"}
sub tcpRtoMin {print "<dt>tcpRtoMin<dd>$tcpRtoMin\n"}
sub tcpRtoMax {print "<dt>tcpRtoMax<dd>$tcpRtoMax\n"}
sub tcpMaxConn {print "<dt>tcpMaxConn<dd>$tcpMaxConn\n"}
sub tcpPassiveOpens {print "<dt>tcpPassiveOpens<dd>$tcpPassiveOpens\n"}
sub tcpAttemptFails {print "<dt>tcpAttemptFails<dd>$tcpAttemptFails\n"}
sub tcpEstabResets {print "<dt>tcpEstabResets<dd>$tcpEstabResets\n"}
sub tcpInSegs {print "<dt>tcpInSegs<dd>$tcpInSegs\n"}
sub tcpOutSegs {print "<dt>tcpOutSegs<dd>$tcpOutSegs\n"}
sub tcpRetransSegs {print "<dt>tcpRetransSegs<dd>$tcpRetransSegs\n"}

sub tcpConnTable { # dl.
	local($i);
	print "<dt>tcpConnTable<dd>\n";
	print "<dl>\n";
	&tcpinfo() unless defined($tcpConnNumber);
	for $i (sort oidorder keys(%tcpConnTable)) {
		&tcpConnEntry($i);
	}
	print "</dl><!-- tcpConnTable -->\n";
}

sub tcpConnEntry { # entry.
	local($i) = @_;
	print "<dt>tcpConnEntry $i<dd>\n";
	print "<dl>\n";
	&tcpConnState($i);
	&tcpConnLocalAddress($i);
	&tcpConnLocalPort($i);
	&tcpConnRemAddress($i);
	&tcpConnRemPort($i);
	print "</dl><!-- tcpConnEntry $i -->\n";
}

sub tcpActiveOpens {
	&tcptbl() unless defined($tcpConnNumber);
	print "<dt>tcpActiveOpens<dd>$tcpActiveOpens\n";
}

sub tcpCurrEstab {
	&tcptbl() unless defined($tcpConnNumber);
	print "<dt>tcpCurrEstab<dd>$tcpCurrEstab\n";
}

sub tcpConnState {
	local($i) = $_[0] || 1;
	&tcptbl() if (!@tcpConnState);
	print "<dt>tcpConnState.$i<dd>" . $tcpConnState{$i} . "\n";
}

sub tcpConnLocalAddress {
	local($i) = $_[0] || 1;
	&tcptbl() if (!@tcpConnLocalAddress);
	print "<dt>tcpConnLocalAddress.$i<dd>" . $tcpConnLocalAddress{$i} . "\n";
}

sub tcpConnLocalPort {
	local($i) = $_[0] || 1;
	&tcptbl() if (!@tcpConnLocalPort);
	print "<dt>tcpConnLocalPort.$i<dd>" . $tcpConnLocalPort{$i} . "\n";
}

sub tcpConnRemAddress {
	local($i) = $_[0] || 1;
	&tcptbl() if (!@tcpConnRemAddress);
	print "<dt>tcpConnRemAddress.$i<dd>" . $tcpConnRemAddress{$i} . "\n";
}

sub tcpConnRemPort {
	local($i) = $_[0] || 1;
	&tcptbl() if (!@tcpConnRemPort);
	print "<dt>tcpConnRemPort.$i<dd>" . $tcpConnRemPort{$i} . "\n";
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub udp { # group.
	print "${G1}udp${G2}\n";
	print "<dl>\n";
	&udpInDatagrams();
	&udpNoPorts();
	&udpInErrors();
	&udpOutDatagrams();
	print "</dl><!-- udp -->\n";
}

sub udpInDatagrams {print "<dt>udpInDatagrams<dd>$udpInDatagrams\n"}
sub udpNoPorts {print "<dt>udpNoPorts<dd>$udpNoPorts\n"}
sub udpInErrors {print "<dt>udpInErrors<dd>$udpInErrors\n"}
sub udpOutDatagrams {print "<dt>udpOutDatagrams<dd>$udpOutDatagrams\n"}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
sub egp { # group.
	print "${G1}egp${G2}\n";
	print "<dl>\n";
	&egpTable();
	print "</dl><!-- egp -->\n";
}

sub egpTable { # group.
	print "<dt>egpTable<dd>\n";
	print "<dl>\n";
	&rttbl() unless $egpNumber;
	print "<dt>#egpTable $egpNumber entries<dd>\n" if $D>2;
	for $a (sort oidorder keys(%egpDest)) {
		&egpEntry($a);
	}
	print "</dl><!-- egpTable -->\n";
}

sub egpEntry { # entry.
	local($i) = @_;
	print "<dt>egpEntry $i<dd>\n";
	print "<dl>\n";
	&egpInMsgs($i);
	&egpInErrors($i);
	&egpOutMsgs($i);
	&egpOutErrors($i);
	&egpNeighTable($i);
	&egpNeighEntry($i);
	&egpNeighState($i);
	&egpNeighAddr($i);
	print "</dl><!-- egpEntry $i -->\n";
}

sub egpInMsgs {print "<dt>egpInMsgs<dd>$egpInMsgs\n"}
sub egpInErrors {print "<dt>egpInErrors<dd>$egpInErrors\n"}
sub egpOutMsgs {print "<dt>egpOutMsgs<dd>$egpOutMsgs\n"}
sub egpOutErrors {print "<dt>egpOutErrors<dd>$egpOutErrors\n"}
sub egpNeighTable {print "<dt>egpNeighTable<dd>$egpNeighTable\n"}
sub egpNeighEntry {print "<dt>egpNeighEntry<dd>$egpNeighEntry\n"}
sub egpNeighState {print "<dt>egpNeighState<dd>$egpNeighState\n"}
sub egpNeighAddr {print "<dt>egpNeighAddr<dd>$egpNeighAddr\n"}

1;