pfSense » pfSense Packages

<?php

/*

 * lcdproc_client.php

 *

 * part of pfSense (https://www.pfsense.org/)

 * Copyright (c) 2016-2023 Rubicon Communications, LLC (Netgate)

 * Copyright (c) 2016 Treer

 * Copyright (c) 2011 Michele Di Maria

 * Copyright (c) 2007-2009 Seth Mos <seth.mos@dds.nl>

 * All rights reserved.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

require_once("config.inc");

require_once("functions.inc");

require_once("interfaces.inc");

require_once("pfsense-utils.inc");

require_once("pkg-utils.inc");

require_once("ipsec.inc");

require_once("includes/functions.inc.php");

require_once("/usr/local/pkg/lcdproc.inc");

require_once("system.inc");

/* Calculates non-idle CPU time and returns as a percentage */

function lcdproc_cpu_usage() {

	$duration = 250000;

	$diff = array('user', 'nice', 'sys', 'intr', 'idle');

	$cpuTicks = array_combine($diff, explode(" ", get_single_sysctl("kern.cp_time")));

	usleep($duration);

	$cpuTicks2 = array_combine($diff, explode(" ", get_single_sysctl("kern.cp_time")));

	$totalStart = array_sum($cpuTicks);

	$totalEnd = array_sum($cpuTicks2);

	// Something wrapped ?!?!

	if ($totalEnd <= $totalStart) {

		return 0;

	}

	// Calculate total cycles used

	$totalUsed = ($totalEnd - $totalStart) - ($cpuTicks2['idle'] - $cpuTicks['idle']);

	// Calculate the percentage used

	$cpuUsage = floor(100 * ($totalUsed / ($totalEnd - $totalStart)));

	return $cpuUsage;

}

function get_uptime_stats() {

	exec("/usr/bin/uptime", $output, $ret);

	$temp = explode(",", $output[0]);

	if (stristr($output[0], "day")) {

		$status = "$temp[0] $temp[1]";

	} else {

		$status = "$temp[0] ";

	}

	$status = trim(str_replace("  ", " ", $status));

	$status = substr($status, strpos($status, "up ") + 3);

	return($status);

}

function get_loadavg_stats() {

	exec("/usr/bin/uptime", $output, $ret);

	$temp = preg_split("/ /", $output[0], -1, PREG_SPLIT_NO_EMPTY);

	$count = count($temp);

	return ($count >= 3) ? "{$temp[$count - 3]} {$temp[$count - 2]} {$temp[$count - 1]}" : "Not available";

}

function lcdproc_get_mbuf_stats() {

	$mbuf = "";

	$mbufpercent = "";

	get_mbuf($mbuf, $mbufpercent);

	return($mbuf);

}

function lcdproc_get_package_summary() {

	$total = 0;

	$needsupdating = 0;

	$broken = 0;

	$package_list = get_pkg_info('all', true, true);

	$installed_packages = array_filter($package_list, function($v) {

		return (isset($v['installed']) || isset($v['broken']));

	});

	if (!empty($installed_packages) || is_array($installed_packages)) {

		$total = count($installed_packages);

	}

	foreach ($installed_packages as $pkg) {

		if (isset($pkg['broken'])) {

			$broken += 1;

		} else if (isset($pkg['installed_version']) && isset($pkg['version'])) {

			$version_compare = pkg_version_compare(

			    $pkg['installed_version'], $pkg['version']);

			if ($version_compare == '<') {

				// we're running an older version of the package

				$needsupdating += 1;

			}

		}

	}

	if ($total > 0) {

		$result = "T: {$total}";

		if ($needsupdating > 0) {

			$result .= " NU: {$needsupdating}";

		}

		if ($broken > 0) {

			$result .= " B!: {$broken}";

		}

	} else {

		$result = "None Installed";

	}

	return $result;

}

// Returns CPU temperature if available from the system

function lcdproc_get_cpu_temperature() {

	global $config;

	$unit = config_get_path('installedpackages/lcdprocscreens/config/0/scr_cputemperature_unit', []);

	$temp_out = "";

	$temp_out = get_temp(); // Use function from includes/functions.inc.php

	if ($temp_out !== "") {

		switch ($unit) {

			case "f":

				$cputemperature = ($temp_out * 1.8) + 32;

				return $cputemperature . "F";

				break;

			case "c":

			default:

				return $temp_out . "C";

				break;

		}

	} else {

		// sysctl probably returned "unknown oid"

		return 'CPU Temp N/A';

	}

}

// NTP Status

function lcdproc_get_ntp_status() { // https://github.com/pfsense/pfsense/blob/master/src/usr/local/www/widgets/widgets/ntp_status.widget.php#L36

	global $config;

	if (config_path_enabled('ntpd')) {

		if (config_path_enabled('system', 'ipv6allow')) {

			$inet_version = "";

		} else {

			$inet_version = " -4";

		}

		exec('/usr/local/sbin/ntpq -pnw ' . $inet_version . ' | /usr/bin/tail +3 | /usr/bin/awk -v RS= \'{gsub(/\n[[:space:]][[:space:]]+/," ")}1\'', $ntpq_output);

		return $ntpq_output;

	} else {

		return false;

	}

}

function lcdproc_get_ntp_gps_sat_count() {

	global $config;

 	if (config_path_enabled('ntpd/gps', 'extstatus')) {

		$lookfor['GPGSV'] = config_get_path('ntpd/gps/nmeaset/gpgsv');

		$lookfor['GPGGA'] = !isset($gps_sat) && config_path_enabled('ntpd/gps/nmeaset', 'gpgga');

		$gpsport = fopen('/dev/gps0', 'r+');

		while ($gpsport && ($lookfor['GPGSV'] || $lookfor['GPGGA'])) {

			$buffer = fgets($gpsport);

			if ($lookfor['GPGSV'] && substr($buffer, 0, 6) == '$GPGSV') {

				$gpgsv = explode(',', $buffer);

				$gps_satview = (int)$gpgsv[3];

				return ("SATV: " . $gps_satview);

			} elseif ($lookfor['GPGGA'] && substr($buffer, 0, 6) == '$GPGGA') {

				$gpgga = explode(',', $buffer);

				$gps_sat = (int)$gpgga[7];

				return ("SATU: " . $gps_sat);

			}

		}

	} else {

		return false;

	}

}

function get_version() {

	$version = @file_get_contents("/etc/version");

	$version = trim($version);

	return(g_get('product_name') . " " . $version);

}

// Returns the max frequency in Mhz, or false if powerd is not supported.

// powerd is not supported on all systems - "no cpufreq(4) support" https://redmine.pfsense.org/issues/5739

function get_cpu_maxfrequency() {

	$cpufreqs = get_single_sysctl("dev.cpu.0.freq_levels");

	if (!empty($cpufreqs)) {

		$cpufreqs = explode(" ", trim($cpufreqs));

		$maxfreqs = explode("/", array_shift($cpufreqs));

		return array_shift($maxfreqs);

	} else {

		// sysctrl probably returned "unknown oid 'dev.cpu.0.freq_levels'",

		// see https://redmine.pfsense.org/issues/5739

		return false;

	}

}

// Returns the current frequency in Mhz, or false if powerd is not supported.

// powerd is not supported on all systems - "no cpufreq(4) support" https://redmine.pfsense.org/issues/5739

function get_cpu_currentfrequency() {

	$curfreq = get_single_sysctl("dev.cpu.0.freq");

	if (!empty($curfreq)) {

		return trim($curfreq);

	} else {

		// sysctrl probably returned "unknown oid 'dev.cpu.0.freq'",

		// see https://redmine.pfsense.org/issues/5739

		return false;

	}

}

function get_cpufrequency() {

	$maxfreq = get_cpu_maxfrequency();

	if ($maxfreq === false) {

		return "no cpufreq(4) support";

	} else {

		$curfreq = get_cpu_currentfrequency();

		return "{$curfreq}\/{$maxfreq} Mhz";

	}

}

function get_interfaces_stats() {

	$ifstatus = [];

	$ifdescrs = get_configured_interface_with_descr();

	foreach ($ifdescrs as $ifdescr => $ifname) {

		$ifinfo = get_interface_info($ifdescr);

		if ($ifinfo['status'] == "up") {

			$online = "Up";

		} else {

			$online = "Down";

		}

		if (!empty($ifinfo['ipaddr'])) {

			$ip = htmlspecialchars($ifinfo['ipaddr']);

		} else {

			$ip = "-";

		}

		$ifstatus[] = htmlspecialchars($ifname) ." [$online]";

	}

	$status = " ". implode(", ", $ifstatus);

	return($status);

}

function get_carp_stats() {

	if (get_carp_status()) {

		$initcount = 0;

		$mastercount = 0;

		$backupcount = 0;

		foreach (config_get_path('virtualip/vip', []) as $carp) {

			if (!is_array($carp) ||

			    empty($carp) ||

			    $carp['mode'] != "carp") {

				continue;

			}

			$ipaddress = $carp['subnet'];

			$password = $carp['password'];

			$netmask = $carp['subnet_bits'];

			$vhid = $carp['vhid'];

			$advskew = $carp['advskew'];

			$status = get_carp_interface_status("_vip{$carp['uniqid']}");

			switch ($status) {

				case "MASTER":

					$mastercount++;

					break;

				case "BACKUP":

					$backupcount++;

					break;

				case "INIT":

					$initcount++;

					break;

			}

		}

		$status = "";

		if (config_path_enabled('/','virtualip_carp_maintenancemode')) {

			$status .= "CARP is in Maintenance Mode. ";

		}

		$status .= "M/B/I {$mastercount}/{$backupcount}/{$initcount}";

	} else {

		$status = "CARP Disabled";

	}

	return($status);

}

function get_ipsec_tunnel_src($tunnel) {

	global $sad;

	$if = "WAN";

	if ($tunnel['interface']) {

		$if = $tunnel['interface'];

		$realinterface = convert_friendly_interface_to_real_interface_name($if);

		$interfaceip = find_interface_ip($realinterface);

	}

	return $interfaceip;

}

function output_ipsec_tunnel_status($tunnel) {

	global $sad;

	$if = "WAN";

	$interfaceip = get_ipsec_tunnel_src($tunnel);

	$foundsrc = false;

	$founddst = false;

	if (!is_array($sad)) {

		/* we have no sad array, bail */

		return(false);

	}

	foreach ($sad as $sa) {

		if ($sa['src'] == $interfaceip) {

			$foundsrc = true;

		}

		if ($sa['dst'] == $tunnel['remote-gateway']) {

			$founddst = true;

		}

	}

	if ($foundsrc && $founddst) {

		/* tunnel is up */

		$iconfn = "pass";

		return(true);

	} else {

		/* tunnel is down */

		$iconfn = "reject";

		return(false);

	}

}

function get_ipsec_stats() {

	global $sad;

	$sad = array();

	$sad = ipsec_dump_sad();

	$activecounter = 0;

	$inactivecounter = 0;

	foreach (config_get_path('ipsec/phase1', []) as $tunnel) {

		if (!is_array($tunnel) || empty($tunnel)) {

			continue;

		}

		$tun_disabled = "false";

		$foundsrc = false;

		$founddst = false;

		if (isset($tunnel['disabled'])) {

			$tun_disabled = "true";

			continue;

		}

		if (output_ipsec_tunnel_status($tunnel)) {

			/* tunnel is up */

			$iconfn = "true";

			$activecounter++;

		} else {

			/* tunnel is down */

			$iconfn = "false";

			$inactivecounter++;

		}

	}

	if (ipsec_enabled()) {

		$status = "Up/Down {$activecounter}/{$inactivecounter}";

	} else {

		$status = "IPsec Disabled";

	}

	return($status);

}

function send_lcd_commands($lcd, $lcd_cmds) {

	if (!is_array($lcd_cmds) || (empty($lcd_cmds))) {

		lcdproc_warn("Failed to interpret lcd commands");

		return;

	}

	get_lcd_messages($lcd);

	foreach ($lcd_cmds as $lcd_cmd) {

		if (! fwrite($lcd, "$lcd_cmd\n")) {

			lcdproc_warn("Connection to LCDd process lost {$errstr} ({$errno})");

			$lcdproc_connect_errors++;

			return false;

		}

	}

	return true;

}

function get_lcd_messages($lcd) {

	while (($cmd_output = fgets($lcd, 8000)) !== false) {

		if (preg_match("/^huh?/", $cmd_output)) {

			lcdproc_notice("LCDd output: \"{$cmd_output}\". Executed \"{$lcd_cmd}\"");

		}

		if (cmenu_enabled()) {

			if (preg_match("/^menuevent select cm_ask_enter/", $cmd_output)) {

				lcdproc_notice("Entering CARP Maintenance Mode");

				interfaces_carp_set_maintenancemode(true);

			}

			if (preg_match("/^menuevent select p_ask_yes/", $cmd_output)) {

				lcdproc_notice("Restarting PHP and GUI!");

				exec("/etc/rc.php-fpm_restart");

				exec("/etc/rc.restart_webgui");

			}

			if (preg_match("/^menuevent select cm_ask_leave/", $cmd_output)) {

				lcdproc_notice("Leaving CARP Maintenance Mode");

				interfaces_carp_set_maintenancemode(false);

			}

			if (preg_match("/^menuevent select r_ask_yes/", $cmd_output)) {

				lcdproc_notice("init REBOOT!");

				system_reboot();

			}

			if (preg_match("/^menuevent select s_ask_yes/", $cmd_output)) {

				lcdproc_notice("init SHUTDOWN!");

				system_halt();

			}

		}

	}

}

function get_lcdpanel_width() {

	$lcdproc_size = config_get_path('installedpackages/lcdproc/config/0/size');

	if (is_null($lcdproc_size)) {

		return "16";

	} else {

		$dimensions = explode("x", $lcdproc_size);

		return $dimensions[0];

	}

}

function get_lcdpanel_height() {

	$lcdproc_size = config_get_path('installedpackages/lcdproc/config/0/size');

	if (is_null($lcdproc_size)) {

		return "2";

	} else {

		$dimensions = explode("x", $lcdproc_size);

		return $dimensions[1];

	}

}

function get_lcdpanel_refresh_frequency() {

	return config_get_path('installedpackages/lcdproc/config/0/refresh_frequency', 5);

}

function outputled_enabled_CFontzPacket() {

	$driver = config_get_path('installedpackages/lcdproc/config/0/driver');

	$outputleds = config_get_path('installedpackages/lcdproc/config/0/outputleds');

	if (is_null($outputleds)) {

		return false;

	} else {

		if ($outputleds && ($driver == "CFontzPacket")) {

			return true;

		} else {

			return false;

		}

	}

}

function cmenu_enabled() {

	return config_path_enabled('installedpackages/lcdproc/config/0', 'controlmenu');

}

function outputled_carp() {

	/* Returns the status of CARP for the box.

	Assumes ALL CARP status are the same for all the interfaces.

		-1 = CARP Disabled

		0  = CARP on Backup

		1  = CARP on Master */

	if (get_carp_status()) {

		foreach (config_get_path('virtualip/vip', []) as $carp) {

			if (!is_array($carp) ||

			    empty($carp) ||

			    $carp['mode'] != "carp") {

				continue;

			}

			$status = get_carp_interface_status("_vip{$carp['uniqid']}");

			switch($status) {

				case "MASTER":

					return 1;

					break;

				case "BACKUP":

				default:

					return 0;

					break;

			}

		}

	} else {

		return -1;

	}

}

function outputled_gateway() {

	/* Returns the status of the gateways.

		-1 = No gateway defined

		0  = At least 1 gateway down or with issues

		1  = All gateway up */

	$gateways_status = return_gateways_status(true);

	if (empty($gateways_status)) {

		return -1;

	}

	foreach ($gateways_status as $gw) {

		if ($gw['status'] != 'online') {

			return 0;

		}

	}

	return 1;

}

function build_interface_link_list() {

	// Returns a dictionary of all the interfaces along with their

	// link and address information, keyed on the interface description.

	$result = array();

	$ifList = get_configured_interface_with_descr();

	foreach($ifList as $ifdescr => $ifname) {

		// get the interface link infos

		$ifinfo = get_interface_info($ifdescr);

		$entry = array();

		$entry['name'] = $ifname;

		$entry['mac'] = $ifinfo['macaddr'];

		if (($ifinfo['status'] == "up") ||

		    ($ifinfo['status'] == "associated")) {

			$entry['status'] = "up";

		} else {

			$entry['status'] = "down";

		}

		if (($ifinfo['pppoelink'] == "up") ||

		    ($ifinfo['pptplink']  == "up") ||

		    ($ifinfo['l2tplink']  == "up")) {

			$entry['link'] = sprintf(gettext("Uptime %s"), $ifinfo['ppp_uptime']);

		} else {

			$entry['link'] = $ifinfo['media'];

		}

		$entry['v4addr'] = (empty($ifinfo['ipaddr'])) ?

			"n/a" : $ifinfo['ipaddr'];

		$entry['v6addr'] = (empty($ifinfo['ipaddrv6'])) ?

			"n/a" : $ifinfo['ipaddrv6'];

		$result[$ifdescr] = $entry;

	}

	return $result;

}

function build_interface_traffic_stats_list() {

	// Returns a dictionary of all the interfaces along with their in/out

	// traffic stats, keyed on the interface name.

	global $config;

	$result = array();

	$interfaceList = get_configured_interface_with_descr();

	foreach($interfaceList as $key => $description) {

		// get the interface stats (code from ifstats.php)

		$interface      = $config['interfaces'][$key];

		$interfaceName  = $interface['if'];

		$interfaceStats = pfSense_get_interface_stats($interfaceName);

		calculate_interfaceBytesPerSecond_sinceLastChecked($interfaceName, $interfaceStats, $in_Bps, $out_Bps);

		calculate_bytesToday($interfaceName, $interfaceStats, $in_bytesToday, $out_bytesToday);

		$entry = array();

		$entry['descr']       = $description;

		$entry['in_Bps']      = $in_Bps;

		$entry['out_Bps']     = $out_Bps;

		$entry['total_Bps']   = $in_Bps + $out_Bps;

		$entry['in_bytes']    = $interfaceStats['inbytes'];

		$entry['out_bytes']   = $interfaceStats['outbytes'];

		$entry['total_bytes'] = $interfaceStats['inbytes'] + $interfaceStats['outbytes'];

		$entry['in_bytes_today']    = $in_bytesToday;

		$entry['out_bytes_today']   = $out_bytesToday;

		$entry['total_bytes_today'] = $in_bytesToday + $out_bytesToday;

		$result[$interface['if']] = $entry;

	}

	return $result;

}

function sort_interface_list_by_bytes_today(&$interfaceTrafficStatsList) {

	uasort($interfaceTrafficStatsList, "cmp_total_bytes_today");

}

function sort_interface_list_by_total_bytes(&$interfaceTrafficStatsList) {

	uasort($interfaceTrafficStatsList, "cmp_total_bytes");

}

function sort_interface_list_by_bps(&$interfaceTrafficStatsList) {

	uasort($interfaceTrafficStatsList, "cmp_total_Bps");

}

function cmp_total_Bps($a, $b) {

	if ($a['total_Bps'] == $b['total_Bps']) return 0;

	return ($a['total_Bps'] < $b['total_Bps']) ? 1 : -1;

}

function cmp_total_bytes($a, $b) {

	if ($a['total_bytes'] == $b['total_bytes']) return 0;

	return ($a['total_bytes'] < $b['total_bytes']) ? 1 : -1;

}

function cmp_total_bytes_today($a, $b) {

	if ($a['total_bytes_today'] == $b['total_bytes_today']) return 0;

	return ($a['total_bytes_today'] < $b['total_bytes_today']) ? 1 : -1;

}

function calculate_interfaceBytesPerSecond_sinceLastChecked($interfaceName, $interfaceStats, &$in_Bps, &$out_Bps) {

	// calculates the average bytes-per-second (in & out) for the interface

	// during the interval between now and the last time this method was invoked for

	// the interface. So avoid invoking this method needlessly, or you'll end up

	// measuring meaningless periods.

	global $traffic_last_ugmt, $traffic_last_ifin, $traffic_last_ifout;

	// get the current time (code from ifstats.php)

	$temp = gettimeofday();

	$timing = (double)$temp["sec"] + (double)$temp["usec"] / 1000000.0;

	// calculate the traffic stats

	$deltatime = $timing - $traffic_last_ugmt[$interfaceName];

	$in_Bps  = ((double)$interfaceStats['inbytes']  - $traffic_last_ifin[$interfaceName])  / $deltatime;

	$out_Bps = ((double)$interfaceStats['outbytes'] - $traffic_last_ifout[$interfaceName]) / $deltatime;

	$traffic_last_ugmt[$interfaceName]  = $timing;

	$traffic_last_ifin[$interfaceName]  = (double)$interfaceStats['inbytes'];

	$traffic_last_ifout[$interfaceName] = (double)$interfaceStats['outbytes'];

}

function calculate_bytesToday($interfaceName, $interfaceStats, &$in_bytesToday, &$out_bytesToday) {

	global $traffic_last_hour, $traffic_startOfDay_ifin, $traffic_startOfDay_ifout;

	$hourOfDay = getdate()['hours'];

	if (!isset($traffic_last_hour[$interfaceName]) || ($hourOfDay < $traffic_last_hour[$interfaceName])) {

		$traffic_startOfDay_ifin[$interfaceName]  = (double)$interfaceStats['inbytes'];

		$traffic_startOfDay_ifout[$interfaceName] = (double)$interfaceStats['outbytes'];

	}

	$traffic_last_hour[$interfaceName] = $hourOfDay;

	$in_bytesToday  = ((double)$interfaceStats['inbytes']  - $traffic_startOfDay_ifin[$interfaceName]);

	$out_bytesToday = ((double)$interfaceStats['outbytes'] - $traffic_startOfDay_ifout[$interfaceName]);

}

function format_interface_string($interfaceEntry, $in_key, $out_key, $output_in_bits, $outputLength) {

	if ($output_in_bits) {

		$speed = " " . format_toSpeedInBits_shortForm($interfaceEntry[$in_key]) . "/" . format_toSpeedInBits_shortForm($interfaceEntry[$out_key]);

	} else {

		$speed = " " . format_toSizeInBytes_shortForm($interfaceEntry[$in_key]) . "/" . format_toSizeInBytes_shortForm($interfaceEntry[$out_key]);

	}

	$nameLength = $outputLength - strlen($speed);

	if ($nameLength < 0) {

		// owch - speed doesn't even fit on the lcd

		$speed = substr(trim($speed), 0, $outputLength);

		$name = '';

	} else {

		$name = substr($interfaceEntry['descr'], 0, $nameLength);

		$name = str_pad($name, $nameLength);

	}

	return $name . $speed;

}

function format_toSizeInBytes_shortForm($size_in_bytes) {

	// format a byte count into a string with two significant figures or more and a unit

	//

	// Data sizes are normally specified in KB - powers of 1024, so return KB rather than kB

	if ($size_in_bytes < (1024 * 1024)) {

		$unit = "K";

		$unitSize = $size_in_bytes / 1024;

	} else if ($size_in_bytes < (1024 * 1024 * 1024)) {

		$unit = "M";

		$unitSize = $size_in_bytes / (1024 * 1024);

	} else {

		$unit = "G";

		$unitSize = $size_in_bytes / (1024 * 1024 * 1024);

	}

	$showDecimalPlace = $unitSize < 10 && round($unitSize, 1) != round($unitSize);

	return sprintf($showDecimalPlace ? "%1.1f" : "%1.0f", $unitSize) . $unit;

}

function format_toSpeedInBits_shortForm($speed_in_bytes) {

	// format a byte-count into a bit-count string with two significant figures or more, and a unit.

	//

	// The decimal SI kilobot definition of 1 kbit/s = 1000 bit/s, is used uniformly in the

	// context of telecommunication transmission, so return kb rather than Kb

	if ($speed_in_bytes < 125000) {

		$unit = "k";

		$unitSpeed = $speed_in_bytes / 125;

	} else if ($speed_in_bytes < 125000000) {

		$unit = "m";

		$unitSpeed = $speed_in_bytes / 125000;

	} else {

		$unit = "g";

		$unitSpeed = $speed_in_bytes / 125000000;

	}

	$showDecimalPlace = $unitSpeed < 10 && round($unitSpeed, 1) != round($unitSpeed);

	return sprintf($showDecimalPlace ? "%1.1f" : "%1.0f", $unitSpeed) . $unit;

}

function format_toSpeedInBits_longForm($speed_in_bytes) {

	/* format speed in bits/sec, input: bytes/sec

	Code from: graph.php ported to PHP

	The decimal SI kilobot definition of 1 kbit/s = 1000 bit/s, is used uniformly in the

	context of telecommunication transmission, so return kb rather than Kb */

	if ($speed_in_bytes < 125000) {

		return sprintf("%5.1f kbps", $speed_in_bytes / 125);

	}

	if ($speed_in_bytes < 125000000) {

		return sprintf("%5.1f mbps", $speed_in_bytes / 125000);

	}

	return sprintf("%5.1f gbps", $speed_in_bytes / 125000000);

}

function get_traffic_stats($interface_traffic_list, &$in_data, &$out_data){

	$ifnum = config_get_path('installedpackages/lcdprocscreens/config/0/scr_traffic_interface');

	/* get the real interface name (code from ifstats.php)*/

	$realif = get_real_interface($ifnum);

	if (!$realif) {

		$realif = $ifnum; // Need for IPsec case interface.

	}

	$interfaceEntry = $interface_traffic_list[$realif];

	$in_data  = "IN:  " . format_toSpeedInBits_longForm($interfaceEntry['in_Bps']);

	$out_data = "OUT: " . format_toSpeedInBits_longForm($interfaceEntry['out_Bps']);

}

function get_top_interfaces_by_bps($interfaceTrafficList, $lcdpanel_width, $lcdpanel_height) {

	$result = [];

	if (count($interfaceTrafficList) < $lcdpanel_height) {

		// All the interfaces will fit on the screen, so use the same sort order as

		// the bytes_today screen, so that the interfaces stay in one place (much easier to read)

		sort_interface_list_by_total_bytes($interfaceTrafficList);

	} else {

		// We can't show all the interfaces, so show the ones with the most traffic

		sort_interface_list_by_bps($interfaceTrafficList);

	}

	foreach($interfaceTrafficList as $interfaceEntry) {

		$result[] = format_interface_string($interfaceEntry, 'in_Bps', 'out_Bps', true, $lcdpanel_width);

	}

	return $result;

}

function get_top_interfaces_by_bytes_today($interfaceTrafficList, $lcdpanel_width) {

	$result = [];

	if (count($interfaceTrafficList) < $lcdpanel_height) {

		// All the interfaces will fit on the screen, so use the same sort order as

		// the bytes_today screen and the bps screen, so that the interfaces stay in

		// one place (much easier to read)

		sort_interface_list_by_total_bytes($interfaceTrafficList);

	} else {

		// We can't show all the interfaces, so show the ones with the most traffic	today

		sort_interface_list_by_bytes_today($interfaceTrafficList);

	}

	foreach($interfaceTrafficList as $interfaceEntry) {

		$result[] = format_interface_string($interfaceEntry, 'in_bytes_today', 'out_bytes_today', false, $lcdpanel_width);

	}

	return $result;

}

function get_top_interfaces_by_total_bytes($interfaceTrafficList, $lcdpanel_width) {

	$result = [];

	sort_interface_list_by_total_bytes($interfaceTrafficList);

	foreach($interfaceTrafficList as $interfaceEntry) {

		$result[] = format_interface_string($interfaceEntry, 'in_bytes', 'out_bytes', false, $lcdpanel_width);

	}

	return $result;

}

function convert_bandwidth_to_shortform($bytes_string) {

	// Shorten values from bandwidth_by_ip.php, which have the form

	// "168.16k", "10.31k", "0.00".

	// The unit is preserved, but decimal point is dropped for 10 or

	// higher, and only 1 decimal place is kept for lower than 10.

	// So "168.16k", "10.31k", "0.00" becomes "168k", "10k", "0"

	if ($bytes_string == "0.00") {

		return "0";

	}

	$decimalPos = strpos($bytes_string, '.');

	if ($decimalPos == 1) {

		// allow 1 decimal place

		return substr($bytes_string, 0, 3) . substr($bytes_string, 4);

	} elseif ($decimalPos > 1) {

		// remove the decimal places

		return substr($bytes_string, 0, $decimalPos) . substr($bytes_string, $decimalPos + 3);

	} else {

		// Our format assumptions are wrong

		return $bytes_string;

	}

}

function get_bandwidth_by_ip() {

	$result       = [];

	/* Ideally this would use /usr/local/www/bandwidth_by_ip.php, but that requires a

	 * logged-in authenticated user session, so use a local copy instead that's outside

	 * the www directory and doesn't require an authenticated user session.

	 */

	/* Start with parameter name and '=' */

	$lan          = 'if=';

	$sort         = 'sort=';

	$filter       = 'filter=';

	$hostipformat = 'hostipformat=';

	/* Add config value */

	$lan          .= config_get_path('installedpackages/lcdprocscreens/config/0/scr_traffic_by_address_if');

	$sort         .= config_get_path('installedpackages/lcdprocscreens/config/0/scr_traffic_by_address_sort');

	$filter       .= config_get_path('installedpackages/lcdprocscreens/config/0/scr_traffic_by_address_filter');

	$hostipformat .= config_get_path('installedpackages/lcdprocscreens/config/0/scr_traffic_by_address_hostipformat');

	/* Escape before using in shell */

	$lan          = escapeshellarg($lan);

	$sort         = escapeshellarg($sort);

	$filter       = escapeshellarg($filter);

	$hostipformat = escapeshellarg($hostipformat);

	$output = shell_exec("/usr/local/bin/php-cgi -f /usr/local/pkg/lcdproc_bandwidth_by_ip.php {$lan} {$sort} {$filter} {$hostipformat}");