poller_mactrack.php

#!/usr/bin/php -q
<?php
/*
 +-------------------------------------------------------------------------+
 | Copyright (C) 2004-2026 The Cacti Group                                 |
 |                                                                         |
 | This program is free software; you can redistribute it and/or           |
 | modify it under the terms of the GNU General Public License             |
 | as published by the Free Software Foundation; either version 2          |
 | of the License, or (at your option) any later version.                  |
 |                                                                         |
 | This program is distributed in the hope that it will be useful,         |
 | but WITHOUT ANY WARRANTY; without even the implied warranty of          |
 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           |
 | GNU General Public License for more details.                            |
 +-------------------------------------------------------------------------+
 | Cacti: The Complete RRDTool-based Graphing Solution                     |
 +-------------------------------------------------------------------------+
 | This code is designed, written, and maintained by the Cacti Group. See  |
 | about.php and/or the AUTHORS file for specific developer information.   |
 +-------------------------------------------------------------------------+
 | http://www.cacti.net/                                                   |
 +-------------------------------------------------------------------------+
*/

if (function_exists('pcntl_async_signals')) {
	pcntl_async_signals(true);
} else {
	declare(ticks = 100);
}

ini_set('output_buffering', 'Off');
ini_set('max_runtime', '-1');
ini_set('memory_limit', '-1');

ini_set('max_execution_time', '-1');

set_time_limit(0);
ob_implicit_flush();

$dir = __DIR__;
chdir($dir);

if (substr_count(strtolower($dir), 'mactrack')) {
	chdir('../../');
}

require('./include/cli_check.php');

global $config;
require_once($config['base_path'] . '/lib/poller.php');
require_once($config['base_path'] . '/plugins/mactrack/includes/database.php');
require_once($config['base_path'] . '/plugins/mactrack/lib/mactrack_functions.php');

mactrack_retry_default_site();

// install signal handlers for UNIX only
if (function_exists('pcntl_signal')) {
	pcntl_signal(SIGTERM, 'sig_handler');
	pcntl_signal(SIGINT, 'sig_handler');
}

// get the mactrack polling cycle
$collect_frequency = read_config_option('mt_collection_timing');
$poller_interval   = read_config_option('poller_interval');

if (is_numeric($collect_frequency)) {
	// let PHP a 5 minutes less than the rerun frequency
	$max_run_duration = ($collect_frequency * 60) - $poller_interval;
} else {
	// default for force
	$max_run_duration = 1800;
}

// Disable Mib File Loading
putenv('MIBS=:');

global $config, $debug, $web, $track_errors;

// initialize variables
$site_id = 0;
$debug   = false;
$force   = false;
$web     = false;

$track_errors = 0;

// process calling arguments
$parms = $_SERVER['argv'];
array_shift($parms);

if (cacti_sizeof($parms)) {
	foreach ($parms as $parameter) {
		if (strpos($parameter, '=') !== false) {
			[$arg, $value] = explode('=', $parameter);
		} else {
			$arg   = $parameter;
			$value = '';
		}

		switch ($arg) {
			case '-sid':
				$site_id = (int) $value;

				break;
			case '-d':
			case '--debug':
				$debug = true;

				break;
			case '-f':
			case '--force':
				$force = true;

				break;
			case '-w':
			case '--web':
				$web = true;

				break;
			case '--version':
			case '-V':
			case '-v':
				display_version();
				exit;
			case '--help':
			case '-H':
			case '-h':
				display_help();
				exit;
			default:
				print 'ERROR: Invalid Parameter ' . $parameter . PHP_EOL . PHP_EOL;
				display_help();
				exit;
		}
	}
}

// silently end if the registered process is still running, or process table missing
if (function_exists('register_process_start')) {
	if (!register_process_start('mactrack', 'master', $config['poller_id'], $max_run_duration)) {
		mactrack_debug('Another Mactrack Process Still Running');
		exit(0);
	}
}

// Get rid of old/hung processes
clear_old_processes($site_id);

if ($collect_frequency == 'disabled') {
	print 'WARNING: Mactrack scanning frequency is disabled, exiting. You have to enable it in settings.' . PHP_EOL;

	if (function_exists('unregister_process')) {
		unregister_process('mactrack', 'master', $config['poller_id'], getmypid());
	}

	exit(1);
} else {
	// for manual scans, verify if we should run or not
	$running_processes = db_fetch_cell('SELECT COUNT(*) FROM mac_track_processes');

	if ($running_processes) {
		$start_date = db_fetch_cell('SELECT MIN(start_date) FROM mac_track_processes');

		if (time() < (strtotime($start_date) + $max_run_duration) && !$force) {
			print 'NOTE: Mactrack currently running and max run duration not eclipsed.' . PHP_EOL;

			if (function_exists('unregister_process')) {
				unregister_process('mactrack', 'master', $config['poller_id'], getmypid());
			}

			exit(0);
		}

		if ($force) {
			mactrack_debug('WARNING: Forcing Collection although Collection Appears in Process');
			db_execute('TRUNCATE mac_track_processes');
		} else {
			mactrack_debug('WARNING: Stale data found in Matrack process table');
			db_execute('TRUNCATE mac_track_processes');
		}
	}

	// we don't want to see errors in the cacti log
	errors_disable();

	if ($site_id > 0) {
		mactrack_debug('About to enter Mactrack Site Scan Processing');

		// take time and log performance data
		$start = microtime(true);

		collect_mactrack_data($start, $site_id);
	} else {
		mactrack_debug('About to enter Mactrack poller processing');

		if ($force || $collect_frequency > 0) {
			mactrack_debug('Into Processing.  Checking to determine if it\'s time to run.');
			$collect_frequency        = $collect_frequency * 60;

			// find out if it's time to collect device information
			$base_start_time          = read_config_option('mt_base_time');
			$database_maint_time      = read_config_option('mt_maint_time');
			$last_run_time            = read_config_option('mt_last_run_time');
			$last_db_maint_time       = read_config_option('mt_last_db_maint_time');
			$previous_base_start_time = read_config_option('mt_prev_base_time');
			$previous_db_maint_time   = read_config_option('mt_prev_db_maint_time');

			// see if the user desires a new start time
			mactrack_debug('Checking if user changed the start time');

			if (!empty($previous_base_start_time)) {
				if ($base_start_time != $previous_base_start_time) {
					mactrack_debug('Detected that user changed the start time');
					unset($last_run_time);
					db_execute("DELETE FROM settings WHERE name='mt_last_run_time'");
				}
			}

			// see if the user desires a new db maintenance time
			/*
			mactrack_debug('Checking if user changed the maintenance time');
			if (!empty($previous_db_maint_time)) {
				if ($database_maint_time <> $previous_db_maint_time) {
					mactrack_debug('Detected that user changed the db maintenance time');
					unset($last_db_maint_time);
					db_execute("DELETE FROM settings WHERE name='mt_last_db_maint_time'");
				}
			}
			*/

			// set to detect if the user cleared the time between polling cycles
			set_config_option('mt_prev_base_time', $base_start_time);
			set_config_option('mt_prev_db_maint_time', $database_maint_time);

			// determine the next start time
			$current_time = strtotime('now');

			if (empty($last_run_time)) {
				if ($current_time > strtotime($base_start_time)) {
					// if timer expired within a polling interval, then poll
					if (($current_time - 300) < strtotime($base_start_time)) {
						$next_run_time = strtotime(date('Y-m-d') . ' ' . $base_start_time);
					} else {
						$next_run_time = strtotime(date('Y-m-d') . ' ' . $base_start_time) + 3600 * 24;
					}
				} else {
					$next_run_time = strtotime(date('Y-m-d') . ' ' . $base_start_time);
				}
			} else {
				$next_run_time = $last_run_time + $collect_frequency;
			}

			$time_till_next_run = $next_run_time - $current_time;

			if ($time_till_next_run < 0) {
				mactrack_debug('The next run time has been determined to be NOW');
			} else {
				mactrack_debug("The next run time has been determined to be at '" . date('Y-m-d H:i:s', (int) $next_run_time) . "'");
			}

			/*
			if (empty($last_db_maint_time)) {
				$next_db_maint_time = strtotime(date('Y-m-d') . ' ' . $database_maint_time);
			} else {
				$next_db_maint_time = $last_db_maint_time + 24*3600;
			}
			*/

			$db_maint_time = strtotime($database_maint_time);

			if ($last_db_maint_time < $db_maint_time) {
				$next_db_maint_time = $db_maint_time;
			} else {
				$next_db_maint_time = strtotime('Tomorrow ' . $database_maint_time);
			}

			$time_till_next_db_maint = $next_db_maint_time - $current_time;

			if ($time_till_next_db_maint < 0) {
				mactrack_debug('The next database maintenance run time has been determined to be NOW');
			} else {
				mactrack_debug("The next database maintenance run time has been determined to be at '" . date('Y-m-d H:i:s', (int) $next_db_maint_time) . "'");
			}

			if ($time_till_next_run < 0 || $force == true) {
				mactrack_debug('Either a scan has been forced, or it\'s time to check for macs');

				// take time and log performance data
				$start = microtime(true);

				set_config_option('mt_last_run_time', $current_time);

				collect_mactrack_data($start, $site_id);
				log_mactrack_statistics('collect');
			}

			if ($time_till_next_db_maint < 0) {
				// take time and log performance data
				$start = microtime(true);

				set_config_option('mt_last_db_maint_time', $current_time);

				perform_mactrack_db_maint();
				log_mactrack_statistics('maint');
			}
		}
	}

	// show errors now
	errors_restore();
}

if (function_exists('unregister_process')) {
	unregister_process('mactrack', 'master', $config['poller_id'], getmypid());
}

exit(0);

/**
 * Disables PHP's track_errors ini setting and installs
 * mactrack_error_handler() as the active error handler, so that
 * subsequent errors are routed through MacTrack's own logging instead
 * of the default handler.
 *
 * @return void
 *
 * @global bool|string &$track_errors Receives the previous
 *                                   track_errors ini value, for later
 *                                   restoration by errors_restore().
 */
function errors_disable(): void {
	global $track_errors;
	$track_errors = ini_get('track_errors');
	ini_set('track_errors', 0);

	set_error_handler('mactrack_error_handler');
}

/**
 * Restores the track_errors ini setting saved by errors_disable() and
 * reinstates PHP's previous error handler.
 *
 * @return void
 *
 * @global bool|string $track_errors The previous track_errors ini
 *                                  value saved by errors_disable().
 */
function errors_restore(): void {
	global $track_errors;
	ini_set('track_errors', $track_errors);

	restore_error_handler();
}

/**
 * Custom PHP error handler installed by errors_disable(): logs the
 * error (with the originating plugin name extracted from the file
 * path when applicable) to the Cacti log, and for fatal-class errors
 * originating in a plugin, disables that plugin to prevent repeated
 * crashes.
 *
 * @param int    $level   The PHP error level constant (e.g. E_ERROR).
 * @param string $message The error message.
 * @param string $file    The file the error occurred in.
 * @param int    $line    The line number the error occurred on.
 * @param array  $context Unused; retained for error handler signature
 *                       compatibility.
 *
 * @return bool False to allow PHP's normal error handling to continue
 *              (except when IgnoreErrorHandler() suppresses the error
 *              entirely, in which case true is returned).
 *
 * @global array $phperrors Map of PHP error level constants to
 *                         human-readable labels.
 */
function mactrack_error_handler($level, $message, $file, $line, $context = []) {
	global $phperrors;

	if (IgnoreErrorHandler($message)) {
		return true;
	}

	preg_match("/.*\/plugins\/([\w-]*)\/.*/", $file, $output_array);

	$plugin = ($output_array[1] ?? '');
	$error  = 'PHP ' . $phperrors[$level] . ($plugin != '' ? " in  Plugin '$plugin'" : '') . ": $message in file: $file  on line: $line";

	switch ($level) {
		case E_COMPILE_ERROR:
		case E_CORE_ERROR:
		case E_ERROR:
		case E_PARSE:
			if ($plugin != '') {
				api_plugin_disable_all($plugin);
				cacti_log("ERRORS DETECTED - DISABLING PLUGIN '$plugin'");
			}
			cacti_log($error, false, 'ERROR');
			cacti_debug_backtrace('PHP ERROR PARSE');

			break;
		case E_RECOVERABLE_ERROR:
		case E_USER_ERROR:
			cacti_log($error, false, 'ERROR');
			cacti_debug_backtrace('PHP ERROR');

			break;
		case E_COMPILE_WARNING:
		case E_CORE_WARNING:
		case E_USER_WARNING:
		case E_WARNING:
			cacti_log($error, false, 'ERROR');
			cacti_debug_backtrace('PHP ERROR WARNING');

			break;
		case E_NOTICE:
		case E_USER_NOTICE:
			break;
		case E_STRICT:
			cacti_log($error, false, 'ERROR');
			cacti_debug_backtrace('PHP ERROR STRICT');

			break;
		default:
			cacti_log($error, false, 'ERROR');
			cacti_debug_backtrace('PHP ERROR');
	}

	return false;
}

/**
 * Deletes stale mac_track_processes rows (and cleans up their scan
 * locks) for scans that have exceeded the configured maximum script
 * runtime, for the given site (or all sites when $site_id is 0).
 *
 * @param int $site_id The MacTrack site id to limit cleanup to, or 0
 *                     for all sites.
 *
 * @return void
 */
function clear_old_processes($site_id): void {
	// get the max script runtime and kill old scripts
	$max_script_runtime = read_config_option('mt_script_runtime');
	$delete_time        = date('Y-m-d H:i:s', (int) strtotime('-' . $max_script_runtime . ' Minutes'));
	$site_id            = intval($site_id);
	$sql                = 'SELECT mtp.*
		FROM mac_track_processes AS mtp
		INNER JOIN mac_track_devices AS mtd
		ON mtp.device_id=mtd.device_id
		WHERE start_date < ?';
	$params             = [$delete_time];

	if ($site_id > 0) {
		$sql .= ' AND mtd.site_id = ?';
		$params[] = $site_id;
	}

	// remove old processes from the system if they exist
	$old_procs = db_fetch_assoc_prepared($sql, $params);

	if (cacti_sizeof($old_procs)) {
		foreach ($old_procs as $p) {
			$process_id = intval($p['process_id']);

			if ($process_id > 0) {
				if (strstr(PHP_OS, 'WIN')) {
					exec('taskkill /pid ' . $process_id);
				} else {
					exec('kill ' . $process_id);
				}

				cacti_log("WARNING: Removing Hung Mactrack Process for Device '" . $p['device_id'] . "' With Status '" . $p['status'] . "'");
			} else {
				cacti_log("WARNING: Removing Hung Mactrack Process Entry for Device '" . $p['device_id'] . "' With Status '" . $p['status'] . "'");
			}

			db_execute_prepared('DELETE FROM mac_track_processes
				WHERE process_id = ?',
				[$process_id]);
		}
	}
}

/**
 * Main MacTrack data collection routine: launches parallel scanning
 * worker processes for each enabled device (or the devices of a
 * specific site) to collect port/MAC/VLAN/ARP/802.1x data, waiting for
 * all workers to finish or the maximum run duration to elapse.
 *
 * @param float $start   The collection run's start time
 *                      (microtime(true)), used to enforce
 *                      $max_run_duration.
 * @param int   $site_id The MacTrack site id to scan, or 0 to scan all
 *                      sites (default 0).
 *
 * @return void
 *
 * @global int    $max_run_duration Maximum allowed collection run
 *                                 duration in seconds.
 * @global array  $config           Cacti global configuration array.
 * @global bool   $debug            Whether debug output is enabled.
 * @global string $scan_date        The current scan timestamp.
 */
function collect_mactrack_data($start, $site_id = 0): void {
	global $max_run_duration, $config, $debug, $scan_date;

	if (defined('CACTI_BASE_PATH')) {
		$config['base_path'] = CACTI_BASE_PATH;
	}

	// dns resolver binary
	$resolver_launched = false;

	if (read_config_option('mt_reverse_dns') == 'on') {
		$dns_resolver_required = true;
	} else {
		$dns_resolver_required = false;
	}

	// get php binary path
	$command_string = read_config_option('path_php_binary');

	// save the scan date information
	$scan_date = date('Y-m-d H:i:s');
	set_config_option('mt_scan_date', $scan_date);

	// just in case we've run too long
	$exit_mactrack = false;

	// start mainline processing, order by site_id to keep routers grouped with switches
	if ($site_id > 0) {
		$device_ids = db_fetch_assoc_prepared('SELECT device_id
			FROM mac_track_devices
			WHERE site_id = ?
			AND disabled = ""
			ORDER BY last_runduration DESC',
			[$site_id]);
	} else {
		$device_ids = db_fetch_assoc('SELECT device_id
			FROM mac_track_devices
			WHERE disabled = ""
			ORDER BY last_runduration DESC');
	}

	$total_devices = cacti_sizeof($device_ids);

	$concurrent_processes = read_config_option('mt_processes');

	if ($debug == true) {
		$e_debug = ' -d';
	} else {
		$e_debug = '';
	}

	if ($site_id > 0) {
		$e_site = " -sid=$site_id";
	} else {
		$e_site = '';
	}

	// add the parent process to the process list
	db_process_add('-1');

	if ($total_devices) {
		$mac_ip_dns = [];

		// grab arpwatch data
		if (read_config_option('mt_arpwatch') == 'on') {
			$arp_db     = read_config_option('mt_arpwatch_path');
			$delim      = read_config_option('mt_mac_delim');
			$mac_ip_dns = [];

			if (file_exists($arp_db)) {
				$arp_dat = fopen($arp_db, 'r');

				if ($arp_dat) {
					while (!feof($arp_dat)) {
						$line = fgets($arp_dat, 4096);

						if ($line != null) {
							$line = explode('	', $line);

							$mac_ad = explode(':',$line[0]);

							for ($k = 0; $k < 6; $k++) {
								$mac_ad[$k] = strtoupper($mac_ad[$k]);

								if (strlen($mac_ad[$k]) == 1) {
									$mac_ad[$k] = '0' . $mac_ad[$k];
								}
							}

							// create the mac address
							$mac = $mac_ad[0] . $delim . $mac_ad[1] . $delim . $mac_ad[2] . $delim . $mac_ad[3] . $delim . $mac_ad[4] . $delim . $mac_ad[5];

							// update the array
							$mac_ip_dns[$mac]['ip']  = $line[1];
							$mac_ip_dns[$mac]['dns'] = $line[3];
						}
					}
					fclose($arp_dat);

					mactrack_debug('ARPWATCH: IP, DNS & MAC collection complete with ArpWatch');
				} else {
					cacti_log("ERROR: cannot open file ArpWatch database '$arp_db'");
				}
			}
		}

		// scan through all devices
		$j                   = 0;
		$i                   = 0;
		$last_time           = strtotime('now') - 7200;
		$processes_available = $concurrent_processes;

		while ($j < $total_devices) {
			// check for pending signals
			pcntl_signal_dispatch();

			/**
			 * retrieve the number of concurrent mac_track processes to run
			 * default to 10 for now
			 */
			$concurrent_processes = db_fetch_cell("SELECT value FROM settings WHERE name='mt_processes'");

			for ($i = 0; $i < $processes_available; $i++) {
				if (($j + $i) >= $total_devices) {
					break;
				}

				$extra_args = ' -q ' . $config['base_path'] . '/plugins/mactrack/mactrack_scanner.php -id=' . $device_ids[$i + $j]['device_id'] . $e_debug;
				mactrack_debug('CMD: ' . $command_string . $extra_args);
				exec_background($command_string, $extra_args);
			}

			$j = $j + $i;

			// launch the dns resolver if it hasn't been yet
			if (($dns_resolver_required) && (!$resolver_launched)) {
				sleep(2);

				exec_background($command_string, ' -q ' . $config['base_path'] . '/plugins/mactrack/mactrack_resolver.php' . $e_debug . $e_site);

				$resolver_launched = true;

				mactrack_debug('DNS Resolver process launched');
			}

			mactrack_debug('A process cycle launch just completed.');

			/**
			 * wait the correct number of seconds for processes prior to
			 * attempting to update records
			 */
			sleep(2);

			$current_time = strtotime('now');

			if (($current_time - $last_time) > read_config_option('mt_dns_prime_interval')) {
				// resolve some ip's to mac addresses to let the resolver knock them out
				db_execute_prepared('UPDATE mac_track_temp_ports
					INNER JOIN mac_track_ips
					ON mac_track_temp_ports.mac_address=mac_track_ips.mac_address
					AND mac_track_temp_ports.site_id=mac_track_ips.site_id
					SET mac_track_temp_ports.ip_address=mac_track_ips.ip_address,
					mac_track_temp_ports.updated=1
					WHERE mac_track_temp_ports.updated=0
					AND mac_track_ips.scan_date = ?',
					[$scan_date]);

				mactrack_debug('Interum IP addresses to MAC addresses association pass complete.');

				$last_time = $current_time;
			}

			$processes_running = db_fetch_cell('SELECT COUNT(*) FROM mac_track_processes');

			if ($dns_resolver_required) {
				$processes_available = $concurrent_processes - $processes_running + 1;
			} else {
				$processes_available = $concurrent_processes - $processes_running;
			}

			// take time to check for an exit condition
			$current = microtime(true);

			// exit if we've run too long
			if (($current - $start) > $max_run_duration) {
				$exit_mactrack = true;
				cacti_log('ERROR: Mactrack timed out during main script processing.');
				db_execute("DELETE FROM settings WHERE name='mactrack_process_status'");
				db_process_remove('-1');

				break;
			} else {
				set_config_option('mactrack_process_status', "Total:$total_devices Completed:$j");
			}
		}

		// wait for last process to exit
		$processes_running = db_fetch_cell('SELECT COUNT(*)
			FROM mac_track_processes
			WHERE device_id > 0');

		while ($processes_running > 0 && !$exit_mactrack) {
			$processes_running = db_fetch_cell('SELECT COUNT(*)
				FROM mac_track_processes
				WHERE device_id > 0');

			$devices_running = db_fetch_cell("SELECT GROUP_CONCAT(CAST(`device_id` as CHAR) SEPARATOR ', ')
				FROM mac_track_processes");

			/**
			 * wait the correct number of seconds for processes prior to
			 * attempting to update records
			 */
			sleep(2);

			$current_time = strtotime('now');

			if (($current_time - $last_time) > read_config_option('mt_dns_prime_interval')) {
				// resolve some ip's to mac addresses to let the resolver knock them out
				db_execute_prepared('UPDATE mac_track_temp_ports
					INNER JOIN mac_track_ips
					ON mac_track_temp_ports.mac_address=mac_track_ips.mac_address
					AND mac_track_temp_ports.site_id=mac_track_ips.site_id
					SET mac_track_temp_ports.ip_address=mac_track_ips.ip_address,
					mac_track_temp_ports.updated=1
					WHERE mac_track_temp_ports.updated=0
					AND mac_track_ips.scan_date = ?',
					[$scan_date]);

				mactrack_debug('Interum IP addresses to MAC addresses association pass complete.');
			}

			// take time to check for an exit condition
			$current = microtime(true);

			// exit if we've run too long
			if (($current - $start) > $max_run_duration) {
				$exit_mactrack = true;
				cacti_log('ERROR: Mactrack timed out during main script processing.');

				break;
			}

			mactrack_debug('Waiting on ' . $processes_running . ' with id = [' . $devices_running . '] to complete prior to exiting.');
		}

		// if arpwatch is enabled, let's let it pick up the stragglers, based upon IP address first
		if ((read_config_option('mt_arpwatch') == 'on') && (cacti_sizeof($mac_ip_dns))) {
			$ports = db_fetch_assoc('SELECT site_id, device_id, mac_address
				FROM mac_track_temp_ports
				WHERE updated = 0');

			if (cacti_sizeof($ports)) {
				foreach ($ports as $port) {
					if (isset($mac_ip_dns[$port['mac_address']])) {
						if ($mac_ip_dns[$port['mac_address']]['dns'] != '') {
							db_execute_prepared('UPDATE mac_track_temp_ports
								SET updated = 1, ip_address = ?, dns_hostname = ?
								WHERE site_id = ?
								AND device_id = ?
								AND mac_address = ?',
								[
									$mac_ip_dns[$port['mac_address']]['ip'],
									$mac_ip_dns[$port['mac_address']]['dns'],
									$port['site_id'],
									$port['device_id'],
									$port['mac_address']
								]
							);
						} else {
							db_execute_prepared('UPDATE mac_track_temp_ports
								SET updated = 1, ip_address = ?
								WHERE site_id = ?
								AND device_id = ?
								AND mac_address = ?',
								[
									$mac_ip_dns[$port['mac_address']]['ip'],
									$port['site_id'],
									$port['device_id'],
									$port['mac_address']
								]
							);
						}
					}
				}
			}
		}

		// check the arp table for entries
		$ports = db_fetch_assoc('SELECT site_id, device_id, mac_address, ip_address
			FROM mac_track_temp_ports
			WHERE updated = 0');

		if (cacti_sizeof($ports)) {
			foreach ($ports as $port) {
				$macs = db_fetch_row_prepared('SELECT mac_address,ip_address
					FROM mac_track_arp
					WHERE mac_address = ?',
					[$port['mac_address']]);

				if (isset($macs['ip_address'])) {
					db_execute_prepared('UPDATE mac_track_temp_ports
						SET updated=1, ip_address = ?
						WHERE site_id = ?
						AND device_id = ?
						AND mac_address = ?',
						[$macs['ip_address'], $port['site_id'], $port['device_id'], $port['mac_address']]);
				}
			}
		}

		// resolve some ip's to mac addresses to let the resolver knock them out
		db_execute_prepared('UPDATE mac_track_temp_ports
			INNER JOIN mac_track_ips
			ON mac_track_temp_ports.mac_address = mac_track_ips.mac_address
			AND mac_track_temp_ports.site_id = mac_track_ips.site_id
			SET mac_track_temp_ports.ip_address = mac_track_ips.ip_address
			WHERE mac_track_temp_ports.updated = 0
			AND mac_track_ips.scan_date = ?',
			[$scan_date]);

		mactrack_debug('Interum IP addresses to MAC addresses association pass complete.');

		// report out some debugging information
		if ($debug) {
			$site_data = db_fetch_assoc("SELECT site_id, SUBSTRING_INDEX(ip_address, '.', 2) AS subnet_range
				FROM mac_track_temp_ports
				GROUP BY site_id, subnet_range");

			if (cacti_sizeof($site_data)) {
				foreach ($site_data as $record) {
					mactrack_debug(sprintf('Site %s has ip range %s', $record['site_id'], $record['subnet_range']));
				}
			}

			$errors_tp  = db_fetch_cell('SELECT COUNT(*) FROM mac_track_temp_ports WHERE mac_address like "% %"');
			$errors_arp = db_fetch_cell('SELECT COUNT(*) FROM mac_track_ips WHERE mac_address like "% %"');
			mactrack_debug("The Temp Ports table had $errors_tp mac tracks with spaces");
			mactrack_debug("The IP Address table had $errors_arp mac tracks with spaces");
		}

		// populate the vendor_macs for this pass
		db_execute('UPDATE mac_track_temp_ports
			SET vendor_mac=SUBSTRING(mac_address,1,6)');

		mactrack_debug('MAC addresses to Vendor MACS association pass complete.');

		// update the vlan id's table
		db_execute("UPDATE mac_track_vlans SET present='0'");

		db_execute("INSERT INTO mac_track_vlans
			(vlan_id, site_id, device_id, vlan_name, present)
			SELECT vlan_id, site_id, device_id, vlan_name, '1' AS present
			FROM mac_track_temp_ports
			ON DUPLICATE KEY UPDATE vlan_name=VALUES(vlan_name), present=VALUES(present);");

		db_execute("DELETE FROM mac_track_vlans WHERE present='0'");

		mactrack_debug('MAC VLANs in VLAN Table Updated.');

		/**
		 * let the resolver know that the parent process is finished and then wait
		 * for the resolver if applicable
		 */
		db_process_remove('-1');

		while (!$exit_mactrack) {
			// checking to see if the resolver is running
			$resolver_running = db_fetch_row('SELECT *
				FROM mac_track_processes
				WHERE device_id = 0');

			if (cacti_sizeof($resolver_running) == 0) {
				break;
			}

			// take time to check for an exit condition
			$current = microtime(true);

			// exit if we've run too long
			if (($current - $start) > $max_run_duration) {
				$exit_mactrack = true;
				cacti_log('ERROR: Mactrack timed out during main script processing.');

				break;
			}
		}

		// transfer temp port results into permanent table
		db_execute('INSERT INTO mac_track_ports
			(site_id, device_id, hostname, dns_hostname, device_name,
			vlan_id, vlan_name, mac_address, vendor_mac, ip_address,
			port_number, port_name, scan_date, authorized)
			SELECT site_id, device_id, hostname, dns_hostname, device_name,
			vlan_id, vlan_name, mac_address, vendor_mac, ip_address,
			port_number, port_name, scan_date, authorized
			FROM mac_track_temp_ports
			ON DUPLICATE KEY UPDATE site_id=VALUES(site_id), hostname=VALUES(hostname),
			device_name=VALUES(device_name), vlan_id=VALUES(vlan_id), vlan_name=VALUES(vlan_name),
			vendor_mac=VALUES(vendor_mac), ip_address=VALUES(ip_address), dns_hostname=VALUES(dns_hostname),
			port_name=VALUES(port_name), authorized=VALUES(authorized)');

		mactrack_debug('Finished transferring scan results to main table.');

		// transfer the subnet information, although primitive, into the ip_ranges table
		$ip_ranges = db_fetch_assoc("SELECT SUBSTRING_INDEX(`ip_address`,'.',3) AS ip_range,
			site_id,
			COUNT(DISTINCT ip_address) AS ips_current,
			scan_date AS ips_current_date
			FROM mac_track_temp_ports
			WHERE ip_address != ''
			GROUP BY ip_range, site_id");

		if (is_array($ip_ranges)) {
			foreach ($ip_ranges as $ip_range) {
				$range_record = (array) db_fetch_row_prepared('SELECT *
					FROM mac_track_ip_ranges
					WHERE ip_range = ?
					AND site_id = ?',
					[$ip_range['ip_range'], $ip_range['site_id']]);

				if (cacti_sizeof($range_record) == 0) {
					db_execute_prepared('REPLACE INTO `mac_track_ip_ranges`
						(ip_range, site_id, ips_current, ips_current_date)
						VALUES (?, ?, ?, ?)',
						[
							$ip_range['ip_range'],
							$ip_range['site_id'],
							$ip_range['ips_current'],
							$ip_range['ips_current_date']
						]
					);
				} else {
					db_execute_prepared('UPDATE mac_track_ip_ranges
						SET ips_current = ?,
						ips_current_date = ?
						WHERE ip_range = ?
						AND site_id = ?',
						[
							$ip_range['ips_current'],
							$ip_range['ips_current_date'],
							$range_record['ip_range'],
							$range_record['site_id']
						]
					);
				}
			}
		}

		// update the max values if required
		db_execute('UPDATE `mac_track_ip_ranges`
			SET ips_max = ips_current, ips_max_date = ips_current_date
			WHERE ips_current > ips_max');

		// collect statistics
		if ($site_id == 0) {
			$stats = db_fetch_assoc('SELECT site_id,
				COUNT(device_id) AS total_devices,
				SUM(ports_active) AS total_oper_ports,
				SUM(macs_active) AS total_macs,
				SUM(ports_total) AS total_user_ports
				FROM mac_track_devices
				GROUP BY site_id');
		} else {
			$stats = db_fetch_assoc_prepared('SELECT site_id,
				COUNT(device_id) AS total_devices,
				SUM(ports_active) AS total_oper_ports,
				SUM(macs_active) AS total_macs,
				SUM(ports_total) AS total_user_ports
				FROM mac_track_devices
				WHERE site_id = ?
				GROUP BY site_id',
				[$site_id]);
		}

		// collect total device errors
		$errors = db_fetch_assoc('SELECT site_id, snmp_status, COUNT(device_id) AS total_device_errors
			FROM mac_track_devices
			GROUP BY site_id, snmp_status');

		$ips = array_rekey(
			db_fetch_assoc_prepared('SELECT site_id, COUNT(ip_address) AS total_ips
				FROM mac_track_ips
				WHERE scan_date = ?
				GROUP BY site_id',
				[$scan_date]),
			'site_id', 'total_ips'
		);

		$error_count = [];

		foreach ($errors as $error) {
			if (!isset($error_count[$error['site_id']])) {
				$error_count[$error['site_id']] = 0;
			}

			if ($error['snmp_status'] != 3) {
				$error_count[$error['site_id']] += $error['total_device_errors'];
			}
		}

		foreach ($stats as $stat) {
			if (isset($ips[$stat['site_id']])) {
				$num_ips = $ips[$stat['site_id']];
			} else {
				$num_ips = 0;
			}

			db_execute_prepared('UPDATE mac_track_sites
				SET total_devices = ?, total_ips = ?, total_macs = ?,
				total_oper_ports = ?, total_user_ports = ?, total_device_errors = ?
				WHERE site_id = ?',
				[
					$stat['total_devices'],
					$num_ips,
					$stat['total_macs'],
					$stat['total_oper_ports'],
					$stat['total_user_ports'],
					$error_count[$stat['site_id']],
					$stat['site_id']
				]
			);
		}

		mactrack_debug('Finished updating site table with collection statistics.');

		// process macwatch data
		$macwatches = db_fetch_assoc('SELECT * FROM mac_track_macwatch');

		if (cacti_sizeof($macwatches)) {
			$from     = read_config_option('mt_from_email');
			$fromname = read_config_option('mt_from_name');

			foreach ($macwatches as $record) {
				// determine if we should check this one
				$found = (array) db_fetch_row_prepared('SELECT *
					FROM mac_track_temp_ports
					WHERE mac_address = ?',
					[$record['mac_address']]);

				if (cacti_sizeof($found)) {
					// set the subject
					$subject = "MACAUTH Notification: Mac Address '" . $record['mac_address'] . "' Found, For: '" . $record['name'] . "'";

					// set the message with replacements
					$message = str_replace('<IP>', $found['ip_address'], (string) $record['description']);
					$message = str_replace('<MAC>', $found['mac_address'], $message);
					$message = str_replace('<TICKET>', $record['ticket_number'], $message);
					$message = str_replace('<SITENAME>', db_fetch_cell_prepared('SELECT site_name FROM mac_track_sites WHERE site_id = ?', [$found['site_id']]), $message);
					$message = str_replace('<DEVICEIP>', $found['hostname'], $message);
					$message = str_replace('<DEVICENAME>', $found['device_name'], $message);
					$message = str_replace('<PORTNUMBER>', $found['port_number'], $message);
					$message = str_replace('<PORTNAME>', $found['port_name'], $message);

					// send out the email
					if (!$record['discovered'] || $record['notify_schedule'] >= '2') {
						$mail = true;

						if ($record['notify_schedule'] > 2) {
							if (strtotime($record['date_last_notif']) + $record['notify_schedule'] > time()) {
								$mail = false;
							}
						}

						if ($mail) {
							mactrack_mail($record['email_addresses'], $from, $fromname, $subject, $message);
						}
					}

					// update the the correct information
					db_execute_prepared('UPDATE mac_track_macwatch
						SET discovered = 1, date_last_seen=NOW()' .
						(strtotime($record['date_first_seen']) == 0 ? ', date_first_seen=NOW()' : '') . '
						WHERE mac_address = ?',
						[$record['mac_address']]);
				}
			}
		}

		// process macauth data
		$mac_auth_frequency = read_config_option('mt_macauth_email_frequency');

		if ($mac_auth_frequency != 'disabled') {
			$last_macauth_time = read_config_option('mt_last_macauth_time');

			// if it's time to e-mail
			$last_macauth_time   = (int) $last_macauth_time;
			$mac_auth_frequency  = (int) $mac_auth_frequency;

			if (($last_macauth_time + ($mac_auth_frequency * 60) < time()) ||
				($mac_auth_frequency == 0)) {
				mactrack_process_mac_auth_report($mac_auth_frequency, $last_macauth_time);
			}
		}

		// process aggregated data
		db_execute('UPDATE mac_track_aggregated_ports SET active_last=0');

		db_execute_prepared('INSERT INTO mac_track_aggregated_ports
			(site_id, device_id, hostname, device_name,
			vlan_id, vlan_name, mac_address, vendor_mac, ip_address, dns_hostname,
			port_number, port_name, date_last, first_scan_date, count_rec, active_last, authorized)
			SELECT t1.site_id, t1.device_id, t1.hostname, t1.device_name,
			vlan_id, vlan_name, t1.mac_address, vendor_mac, t2.ip_address, t1.dns_hostname,
			t1.port_number, t1.port_name, t1.scan_date, t1.scan_date, 1, 1, authorized
			FROM mac_track_temp_ports t1
			INNER JOIN mac_track_ips t2
			ON (t1.mac_address = t2.mac_address
			AND t1.site_id     = t2.site_id
			AND t1.port_number <> ""
			AND t2.scan_date   = ?)
			ON DUPLICATE KEY UPDATE count_rec=count_rec+1, active_last=1, date_last=t1.scan_date,port_name=t1.port_name',
			[$scan_date]);

		// purge the ip address and temp port table
		db_execute('TRUNCATE TABLE mac_track_temp_ports');

		/*
		db_execute_prepared('DELETE FROM mac_track_ips
			WHERE scan_date < NOW() - interval ? DAY',
			array(read_config_option('mt_data_retention_ip')));

		db_execute('OPTIMIZE TABLE mac_track_ips');
		*/

		db_execute('TRUNCATE TABLE mac_track_scan_dates');
		db_execute('REPLACE INTO mac_track_scan_dates (SELECT DISTINCT scan_date from mac_track_ports)');

		api_plugin_hook_function('mac_track_finish_scan');
	} else {
		cacti_log('NOTE: MACTRACK has no devices to process at this time', false, 'MACTRACK');
	}
}

/**
 * Builds and emails the periodic MAC authentication (802.1x) report,
 * listing newly discovered unauthorized ports/MAC addresses, when the
 * configured report frequency interval has elapsed since the last run
 * (or immediately when $mac_auth_frequency is 0).
 *
 * @param int $mac_auth_frequency Report frequency in seconds (0 means
 *                               always run/report immediately).
 * @param int $last_macauth_time Unix timestamp of the last time this
 *                               report was sent.
 *
 * @return void
 */
function mactrack_process_mac_auth_report($mac_auth_frequency, $last_macauth_time): void {
	if ($mac_auth_frequency == 0) {
		/*
		$ports = db_fetch_assoc('SELECT mac_track_temp_ports.*, mac_track_sites.site_name
			FROM mac_track_temp_ports
			LEFT JOIN mac_track_sites
			ON mac_track_sites.site_id = mac_track_temp_ports.site_id
			WHERE authorized = 0');
		*/
		$ports = db_fetch_assoc('SELECT mac_track_temp_ports.*, mac_track_sites.site_name
			FROM mac_track_temp_ports
			LEFT JOIN mac_track_sites
			ON mac_track_sites.site_id = mac_track_temp_ports.site_id
			WHERE authorized = 0
			AND ip_address <> ""
			AND ip_address IS NOT NULL
			ORDER BY mac_track_temp_ports.device_name, mac_track_temp_ports.port_number, mac_track_temp_ports.scan_date, mac_track_temp_ports.mac_address');
	} else {
		/*
		$ports = db_fetch_assoc('SELECT mac_track_ports.*, mac_track_sites.site_name
			FROM mac_track_ports
			LEFT JOIN mac_track_sites
			ON mac_track_sites.site_id = mac_track_temp_ports.site_id
			WHERE authorized = 0');
		*/
		$ports = db_fetch_assoc('SELECT mac_track_ports.*, mac_track_sites.site_name
			FROM mac_track_ports
			LEFT JOIN mac_track_sites
			ON mac_track_sites.site_id = mac_track_ports.site_id
			WHERE authorized = 0
			AND ip_address <> ""
			AND ip_address IS NOT NULL
			ORDER BY mac_track_ports.device_name, mac_track_ports.port_number, mac_track_ports.scan_date, mac_track_ports.mac_address');
	}

	$from     = read_config_option('mt_from_email');
	$fromname = read_config_option('mt_from_name');
	$to       = read_config_option('mt_macauth_emails');

	if (cacti_sizeof($ports)) {
		// set the subject
		$subject = 'MACAUTH Report ' . date('Y-m-d H:i:s');

		$message = 'Not Authorized devices found:<br><br>';
		$message .= '<table><tr><td>Site Name</td><td>Switch Name</td><td>Switch Hostname</td><td>ED IP Address</td><td>ED MAC Address</td><td>Port Number</td><td>Port Name</td><td>Scan Date</td></tr>';

		foreach ($ports as $port) {
			// create the report
			$message .= '<tr>';
			$message .= '<td>' . $port['site_name'] . '</td>';
			$message .= '<td>' . $port['device_name'] . '</td>';
			$message .= '<td>' . $port['hostname'] . '</td>';
			$message .= '<td>' . $port['ip_address'] . '</td>';
			$message .= '<td>' . $port['mac_address'] . '</td>';
			$message .= '<td>' . $port['port_number'] . '</td>';
			$message .= '<td>' . $port['port_name'] . '</td>';
			$message .= '<td>' . $port['scan_date'] . '</td>';
			$message .= '</tr>';
		}
		$message .= '</table>';

		// email the report
		mactrack_mail($to, $from, $fromname, $subject, $message, $headers = '');
		mactrack_debug('MACAUTH Report eMail sent.');

		// Persist last-run so the schedule gate does not re-fire every poll.
		if ($mac_auth_frequency > 0) {
			set_config_option('mt_last_macauth_time', (string) time());
		}
	} else {
		// email the report

		if ($mac_auth_frequency > 0) {
			// send out an empty report

			// set the subject
			$subject = 'MACAUTH Report OK ' . date('Y-m-d H:i:s');

			$message = 'Unauthorized devices not found.';

			// email the report
			mactrack_mail($to, $from, $fromname, $subject, $message, $headers = '');
			mactrack_debug('MACAUTH Report empty eMail sent.');
			set_config_option('mt_last_macauth_time', (string) time());
		}
	}
}

/**
 * Logs MacTrack collection or maintenance run performance statistics
 * (elapsed time, concurrent process count, device count) to both the
 * Cacti settings table (for display in the UI) and the Cacti log.
 *
 * @param string $type Either 'collect' (default) to log a data
 *                     collection run's stats, or any other value to
 *                     log a database maintenance run's stats.
 *
 * @return void
 *
 * @global float $start   The run's start time (microtime(true)), used
 *                        to compute elapsed time.
 * @global int   $site_id The MacTrack site id the run was scoped to (0
 *                        for all sites), used to compute the device
 *                        count.
 */
function log_mactrack_statistics($type = 'collect'): void {
	global $start, $site_id;

	// let's get the number of devices
	if ($site_id > 0) {
		$devices = db_fetch_cell_prepared('SELECT COUNT(*)
			FROM mac_track_devices
			WHERE site_id = ?',
			[$site_id]);
	} else {
		$devices = db_fetch_cell('SELECT COUNT(*)
			FROM mac_track_devices');
	}

	$concurrent_processes = read_config_option('mt_processes');

	// take time and log performance data
	$end = microtime(true);

	if ($type == 'collect') {
		$cacti_stats = sprintf(
			'Time:%01.4f ' .
			'ConcurrentProcesses:%s ' .
			'Devices:%s ',
			round($end - $start,4),
			$concurrent_processes,
			$devices);

		// log to the database
		set_config_option('stats_mactrack', $cacti_stats);

		// log to the logfile
		cacti_log('MACTRACK STATS: ' . $cacti_stats, true, 'SYSTEM');
	} else {
		$cacti_stats = sprintf('Time:%01.4f', round($end - $start,4));

		// log to the database
		set_config_option('stats_mactrack_maint', $cacti_stats);

		// log to the logfile
		cacti_log('MACTRACK MAINT STATS: ' . $cacti_stats, true, 'SYSTEM');
	}
}

/**
 * sig_handler - provides a generic means to catch exceptions to the Cacti log.
 *
 * @param (int) $signo - the signal that was thrown by the interface.
 *
 * @return (void)
 */
function sig_handler($signo) {
	global $force, $config;

	switch ($signo) {
		case SIGTERM:
		case SIGINT:
			cacti_log("WARNING: MacTrack Poller 'master' is shutting down by signal!", false, 'MACTRACK');

			if (!$force) {
				unregister_process('mactrack', 'master', $config['poller_id'], getmypid());
			}

			exit(1);
		default:
			// ignore all other signals
	}
}

/**
 * Prints this script's name, version, and copyright banner to stdout.
 *
 * @return void
 *
 * @global array $config Cacti global configuration array (declared but
 *                       not used directly here).
 */
function display_version(): void {
	global $config;

	$info = plugin_mactrack_version();
	print 'Mactrack Master Poller, Version ' . $info['version'] . ', ' . COPYRIGHT_YEARS . PHP_EOL;
}

/**
 * Prints this script's version banner followed by its command-line
 * usage instructions to stdout.
 *
 * @return void
 */
function display_help(): void {
	display_version();

	print PHP_EOL;
	print 'usage: poller_mactrack.php [-sid=site_id] [--web] [--force] [--debug]' . PHP_EOL . PHP_EOL;
	print '-sid=site_id  - The mac_track_sites site_id to scan' . PHP_EOL;
	print '-w | --web    - Display output suitable for the web' . PHP_EOL;
	print '-f | --force  - Force the execution of a collection process' . PHP_EOL;
	print '-d | --debug  - Display verbose output during execution' . PHP_EOL;
}