mirror of
https://github.com/billz/raspap-webgui.git
synced 2025-12-26 23:26:47 +01:00
763 lines
26 KiB
PHP
763 lines
26 KiB
PHP
<?php
|
||
|
||
/**
|
||
* A wireless utility class for RaspAP
|
||
* @description A collection of wireless utility methods
|
||
* @author Bill Zimmerman <billzimmerman@gmail.com>
|
||
* @license https://github.com/raspap/raspap-webgui/blob/master/LICENSE
|
||
*/
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace RaspAP\Networking\Hotspot;
|
||
|
||
class WiFiManager
|
||
{
|
||
|
||
private const MIN_RSSI = -100;
|
||
private const MAX_RSSI = -55;
|
||
const SECURITY_OPEN = 'OPEN';
|
||
|
||
public function knownWifiStations(&$networks)
|
||
{
|
||
// find currently configured networks
|
||
exec(' sudo cat ' . RASPI_WPA_SUPPLICANT_CONFIG, $known_return);
|
||
foreach ($known_return as $line) {
|
||
if (preg_match('/network\s*=/', $line)) {
|
||
$network = array('visible' => false, 'configured' => true, 'connected' => false, 'index' => null);
|
||
} elseif (isset($network) && $network !== null) {
|
||
if (preg_match('/^\s*}\s*$/', $line)) {
|
||
$networks[$ssid] = $network;
|
||
$network = null;
|
||
$ssid = null;
|
||
} elseif ($lineArr = preg_split('/\s*=\s*/', trim($line), 2)) {
|
||
switch (strtolower($lineArr[0])) {
|
||
case 'ssid':
|
||
$ssid = trim($lineArr[1], '"');
|
||
$ssid = str_replace('P"','',$ssid);
|
||
$network['ssid'] = $ssid;
|
||
$network['index'] = $this->getNetworkIdBySSID($ssid);
|
||
break;
|
||
case 'psk':
|
||
$network['passkey'] = trim($lineArr[1]);
|
||
$network['protocol'] = 'WPA';
|
||
break;
|
||
case '#psk':
|
||
$network['protocol'] = 'WPA';
|
||
case 'wep_key0': // Untested
|
||
$network['passphrase'] = trim($lineArr[1], '"');
|
||
break;
|
||
case 'key_mgmt':
|
||
if (! array_key_exists('passphrase', $network) && $lineArr[1] === 'NONE') {
|
||
$network['protocol'] = self::SECURITY_OPEN;
|
||
}
|
||
break;
|
||
case 'priority':
|
||
$network['priority'] = trim($lineArr[1], '"');
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Scans for nearby WiFi networks using `iw` and updates the reference array
|
||
*
|
||
* @param array $networks Reference to the array of known and discovered networks
|
||
* @param bool $cached If false, bypasses the cache and performs a fresh scan
|
||
*/
|
||
public function nearbyWifiStations(&$networks, $cached = true)
|
||
{
|
||
$cacheTime = filemtime(RASPI_WPA_SUPPLICANT_CONFIG);
|
||
$cacheKey = "nearby_wifi_stations_$cacheTime";
|
||
|
||
if ($cached == false) {
|
||
deleteCache($cacheKey);
|
||
}
|
||
|
||
$iface = escapeshellarg($_SESSION['wifi_client_interface']);
|
||
|
||
$scan_results = cache(
|
||
$cacheKey,
|
||
function () use ($iface) {
|
||
$stdout = shell_exec("sudo iw dev $iface scan");
|
||
sleep(1);
|
||
if ($stdout === null) {
|
||
return [];
|
||
}
|
||
return preg_split("/\n/", $stdout);
|
||
}
|
||
);
|
||
|
||
// determine the next index that follows the indexes of the known networks
|
||
$index = 0;
|
||
if (!empty($networks)) {
|
||
foreach ($networks as $network) {
|
||
if (isset($network['index']) && is_numeric($network['index']) && ($network['index'] > $index)) {
|
||
$index = (int)$network['index'];
|
||
}
|
||
}
|
||
}
|
||
$index++;
|
||
|
||
$current = [];
|
||
$commitCurrent = function () use (&$current, &$networks, &$index) {
|
||
if (empty($current['ssid'])) {
|
||
return;
|
||
}
|
||
|
||
$ssid = $current['ssid'];
|
||
|
||
// unprintable 7bit ASCII control codes, delete or quotes -> ignore network
|
||
if (preg_match('/[\x00-\x1f\x7f\'`\´"]/', $ssid)) {
|
||
return;
|
||
}
|
||
|
||
$channel = ConvertToChannel($current['freq'] ?? 0);
|
||
$rssi = $current['signal'] ?? -100;
|
||
|
||
// if network is saved
|
||
if (array_key_exists($ssid, $networks)) {
|
||
$networks[$ssid]['visible'] = true;
|
||
$networks[$ssid]['channel'] = $channel;
|
||
if (!isset($networks[$ssid]['RSSI']) || $networks[$ssid]['RSSI'] < $rssi) {
|
||
$networks[$ssid]['RSSI'] = $rssi;
|
||
}
|
||
} else {
|
||
$networks[$ssid] = [
|
||
'ssid' => $ssid,
|
||
'configured' => false,
|
||
'protocol' => $current['security'] ?? self::SECURITY_OPEN,
|
||
'channel' => $channel,
|
||
'passphrase' => '',
|
||
'visible' => true,
|
||
'connected' => false,
|
||
'RSSI' => $rssi,
|
||
'index' => $index
|
||
];
|
||
$index++; // increment for next new network
|
||
}
|
||
};
|
||
|
||
if (is_string($scan_results)) {
|
||
$scan_results = explode("\n", trim($scan_results));
|
||
}
|
||
|
||
foreach ($scan_results as $line) {
|
||
$line = trim($line);
|
||
|
||
if (preg_match('/^BSS\s+([0-9a-f:]{17})/', $line, $match)) {
|
||
$commitCurrent(); // commit previous
|
||
$current = [
|
||
'bssid' => $match[1],
|
||
'ssid' => '',
|
||
'signal' => null,
|
||
'freq' => null,
|
||
'security' => self::SECURITY_OPEN
|
||
];
|
||
continue;
|
||
}
|
||
if (preg_match('/^SSID:\s*(.*)$/', $line, $match)) {
|
||
$current['ssid'] = $match[1];
|
||
continue;
|
||
}
|
||
if (preg_match('/^signal:\s*(-?\d+\.\d+)/', $line, $match)) {
|
||
$current['signal'] = (float)$match[1];
|
||
continue;
|
||
}
|
||
if (preg_match('/^freq:\s*(\d+)/', $line, $match)) {
|
||
$current['freq'] = (int)$match[1];
|
||
continue;
|
||
}
|
||
if (preg_match('/^RSN:/', $line) || preg_match('/^WPA:/', $line)) {
|
||
$current['security'] = 'WPA/WPA2';
|
||
continue;
|
||
}
|
||
}
|
||
$commitCurrent();
|
||
}
|
||
/**
|
||
* Check if networks are connected via wpa_cli status
|
||
* NB: iwconfig shows the last associated SSID even when connection is inactive
|
||
*/
|
||
public function connectedWifiStations(&$networks)
|
||
{
|
||
$wpa_state = null;
|
||
$connected_ssid = null;
|
||
$iface = $_SESSION['wifi_client_interface'];
|
||
|
||
$cmd = "sudo wpa_cli -i $iface status";
|
||
$status_output = shell_exec($cmd);
|
||
|
||
if ($status_output === null || empty($status_output)) {
|
||
error_log("WiFiManager::connectedWifiStations: wpa_cli command failed or returned no output");
|
||
return;
|
||
}
|
||
$lines = explode("\n", trim($status_output));
|
||
|
||
foreach ($lines as $line) {
|
||
$line = trim($line);
|
||
if (preg_match('/^wpa_state=(.+)$/', $line, $matches)) {
|
||
$wpa_state = trim($matches[1]);
|
||
}
|
||
if (preg_match('/^ssid=(.+)$/', $line, $matches)) {
|
||
$connected_ssid = trim($matches[1]);
|
||
}
|
||
}
|
||
|
||
if ($wpa_state === 'COMPLETED' && !empty($connected_ssid)) {
|
||
$ssid = hexSequence2lower($connected_ssid);
|
||
|
||
// check if this SSID exists in networks array
|
||
if (array_key_exists($ssid, $networks)) {
|
||
$networks[$ssid]['connected'] = true;
|
||
} else {
|
||
error_log("WiFiManager::connectedWifiStations: SSID '$ssid' not found. SSIDs: " . implode(', ', array_keys($networks)));
|
||
}
|
||
|
||
// captive portal detection
|
||
// $check = detectCaptivePortal($iface);
|
||
// if (isset($check["URL"])) {
|
||
// $networks[$ssid]["portal-url"] = $check["URL"];
|
||
// }
|
||
}
|
||
}
|
||
|
||
/**
|
||
*
|
||
*
|
||
*/
|
||
public function sortNetworksByRSSI(&$networks)
|
||
{
|
||
$valRSSI = array();
|
||
foreach ($networks as $SSID => $net) {
|
||
if (!array_key_exists('RSSI', $net)) {
|
||
$net['RSSI'] = -1000;
|
||
}
|
||
$valRSSI[$SSID] = $net['RSSI'];
|
||
}
|
||
$nets = $networks;
|
||
arsort($valRSSI);
|
||
$networks = array();
|
||
foreach ($valRSSI as $SSID => $RSSI) {
|
||
$networks[$SSID] = $nets[$SSID];
|
||
$networks[$SSID]['RSSI'] = $RSSI;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Determines the configured wireless AP interface
|
||
*
|
||
* If not saved in /etc/raspap/hostapd.ini, check for a second
|
||
* wireless interface with iw dev. Fallback to the constant
|
||
* value defined in config.php
|
||
*/
|
||
public function getWifiInterface()
|
||
{
|
||
$hostapdIni = RASPI_CONFIG . '/hostapd.ini';
|
||
$arrHostapdConf = file_exists($hostapdIni) ? parse_ini_file($hostapdIni) : [];
|
||
|
||
$iface = $_SESSION['ap_interface'] = $arrHostapdConf['WifiInterface'] ?? RASPI_WIFI_AP_INTERFACE;
|
||
|
||
if (!validateInterface($iface)) {
|
||
$iface = RASPI_WIFI_AP_INTERFACE;
|
||
}
|
||
|
||
// check for 2nd wifi interface -> wifi client on different interface
|
||
exec("iw dev | awk '$1==\"Interface\" && $2!=\"$iface\" {print $2}'", $iface2);
|
||
$client_iface = $_SESSION['wifi_client_interface'] = empty($iface2) ? $iface : trim($iface2[0]);
|
||
|
||
// handle special case for RPi Zero W in AP-STA mode
|
||
if ($client_iface === "uap0" && ($arrHostapdConf['WifiAPEnable'] ?? 0)) {
|
||
$_SESSION['wifi_client_interface'] = $iface;
|
||
$_SESSION['ap_interface'] = $client_iface;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Reinitializes wpa_supplicant for the wireless client interface
|
||
* The 'force' parameter deletes the socket in /var/run/wpa_supplicant/
|
||
*
|
||
* @param boolean $force
|
||
*/
|
||
public function reinitializeWPA($force)
|
||
{
|
||
$iface = $_SESSION['wifi_client_interface'];
|
||
if ($force == true) {
|
||
$cmd = "sudo rm -f /var/run/wpa_supplicant/" . $iface;
|
||
$result = shell_exec($cmd);
|
||
$cmd = "sudo /sbin/wpa_supplicant -i $iface -c /etc/wpa_supplicant/wpa_supplicant.conf -B 2>&1";
|
||
$result = shell_exec($cmd);
|
||
sleep(2);
|
||
}
|
||
$cmd = "sudo wpa_cli -i $iface reconfigure";
|
||
$result = shell_exec($cmd);
|
||
sleep(1);
|
||
return $result;
|
||
}
|
||
|
||
/*
|
||
* Replace escaped bytes (hex) by binary - assume UTF8 encoding
|
||
*
|
||
* @param string $ssid
|
||
*/
|
||
public function ssid2utf8($ssid)
|
||
{
|
||
return evalHexSequence($ssid);
|
||
}
|
||
|
||
/*
|
||
* Returns a signal strength indicator based on RSSI value
|
||
*
|
||
* @param string $rssi
|
||
*/
|
||
public function getSignalBars($rssi)
|
||
{
|
||
// assign css class based on RSSI value
|
||
$class = '';
|
||
if ($rssi >= SELF::MAX_RSSI) {
|
||
$class = 'strong';
|
||
} elseif ($rssi >= -56) {
|
||
$class = 'medium';
|
||
} elseif ($rssi >= -67) {
|
||
$class = 'weak';
|
||
} elseif ($rssi >= -89) {
|
||
$class = '';
|
||
}
|
||
|
||
// calculate percent strength
|
||
if ($rssi >= -50) {
|
||
$pct = 100;
|
||
} elseif ($rssi <= SELF::MIN_RSSI) {
|
||
$pct = 0;
|
||
} else {
|
||
$pct = 2*($rssi + 100);
|
||
}
|
||
$elem = '<div data-toggle="tooltip" title="' . _("Signal strength"). ': ' .$pct. '%" class="signal-icon ' .$class. '">'.PHP_EOL;
|
||
for ($n = 0; $n < 3; $n++ ) {
|
||
$elem .= '<div class="signal-bar"></div>'.PHP_EOL;
|
||
}
|
||
$elem .= '</div>'.PHP_EOL;
|
||
return $elem;
|
||
}
|
||
|
||
/**
|
||
* Parses output of wpa_cli list_networks, compares with known networks
|
||
* from wpa_supplicant, and adds with wpa_cli if not found
|
||
*
|
||
* @param array $networks
|
||
* @throws Exception on wpa_cli command failure
|
||
*/
|
||
public function setKnownStationsWPA($networks)
|
||
{
|
||
$this->ensureWpaSupplicant();
|
||
|
||
$iface = escapeshellarg($_SESSION['wifi_client_interface']);
|
||
$output = shell_exec("sudo wpa_cli -i $iface list_networks 2>&1");
|
||
|
||
if ($output === null) {
|
||
throw new \Exception("Failed to execute wpa_cli command - command returned null");
|
||
}
|
||
|
||
// check for common wpa_cli errors and try to fix them
|
||
if (strpos($output, 'Failed to connect') !== false || strpos($output, 'No such file or directory') !== false) {
|
||
error_log("wpa_supplicant not available for interface, attempting to start it");
|
||
|
||
// try starting wpa_supplicant for this interface
|
||
$unescapedIface = trim($iface, "'\"");
|
||
$startCmd = "sudo /sbin/wpa_supplicant -i $unescapedIface -c /etc/wpa_supplicant/wpa_supplicant.conf -B 2>&1";
|
||
$startResult = shell_exec($startCmd);
|
||
sleep(2);
|
||
|
||
// retry
|
||
$output = shell_exec("sudo wpa_cli -i $iface list_networks 2>&1");
|
||
|
||
// if it still fails, throw an exception
|
||
if ($output === null || strpos($output, 'Failed to connect') !== false) {
|
||
throw new \Exception("Failed to start wpa_supplicant for interface: " . trim($startResult ?? 'unknown error'));
|
||
}
|
||
}
|
||
|
||
// split output into lines
|
||
$lines = explode("\n", trim($output));
|
||
|
||
// check for header line
|
||
if (empty($lines) || count($lines) < 1) {
|
||
error_log("wpa_cli list_networks returned no output");
|
||
$wpaCliNetworks = [];
|
||
} else {
|
||
// remove header line if it exists
|
||
$headerLine = trim($lines[0]);
|
||
if (strpos($headerLine, 'network id') !== false || strpos($headerLine, 'id') !== false) {
|
||
array_shift($lines);
|
||
}
|
||
|
||
$wpaCliNetworks = [];
|
||
foreach ($lines as $line) {
|
||
$trimmedLine = trim($line);
|
||
|
||
// skip empty lines
|
||
if (empty($trimmedLine)) {
|
||
continue;
|
||
}
|
||
|
||
$data = explode("\t", $trimmedLine);
|
||
if (count($data) >= 2) {
|
||
$id = trim($data[0]);
|
||
$ssid = trim($data[1]);
|
||
|
||
// add if we have valid data
|
||
if ($id !== '' && $ssid !== '') {
|
||
$wpaCliNetworks[] = [
|
||
'id' => $id,
|
||
'ssid' => $ssid
|
||
];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// process networks to add
|
||
foreach ($networks as $network) {
|
||
if (!isset($network['ssid']) || empty($network['ssid'])) {
|
||
error_log("Skipping network with missing or empty SSID");
|
||
continue;
|
||
}
|
||
|
||
$ssid = $network['ssid'];
|
||
if (!$this->networkExists($ssid, $wpaCliNetworks)) {
|
||
$this->addWpaNetwork($network, $iface);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Helper method to add a single network to wpa_supplicant
|
||
*
|
||
* @param array $network Network configuration
|
||
* @param string $iface Escaped shell argument for interface
|
||
*/
|
||
private function addWpaNetwork($network, $iface)
|
||
{
|
||
$ssid = escapeshellarg('"' . $network['ssid'] . '"');
|
||
$psk = escapeshellarg('"' . $network['passphrase'] . '"');
|
||
$protocol = $network['protocol'] ?? 'WPA';
|
||
|
||
// add network and get its ID
|
||
$netid = trim(shell_exec("sudo wpa_cli -i $iface add_network 2>&1"));
|
||
|
||
// validate network ID
|
||
if (!$netid || !is_numeric($netid)) {
|
||
error_log("Failed to add network '{$network['ssid']}': Invalid network ID returned: '$netid'");
|
||
return;
|
||
}
|
||
|
||
// prepare command based on protocol
|
||
$commands = [
|
||
"sudo wpa_cli -i $iface set_network $netid ssid $ssid",
|
||
];
|
||
|
||
if ($protocol === self::SECURITY_OPEN) {
|
||
$commands[] = "sudo wpa_cli -i $iface set_network $netid key_mgmt NONE";
|
||
} else {
|
||
$commands[] = "sudo wpa_cli -i $iface set_network $netid psk $psk";
|
||
}
|
||
|
||
$commands[] = "sudo wpa_cli -i $iface enable_network $netid";
|
||
|
||
// execute commands, checking errors
|
||
foreach ($commands as $cmd) {
|
||
$result = shell_exec("$cmd 2>&1");
|
||
if ($result === null || strpos($result, 'FAIL') !== false) {
|
||
error_log("Command failed: $cmd - Result: " . ($result ?? 'null'));
|
||
// remove the failed network
|
||
shell_exec("sudo wpa_cli -i $iface remove_network $netid 2>&1");
|
||
return;
|
||
}
|
||
usleep(1000);
|
||
}
|
||
error_log("Successfully added network: {$network['ssid']}");
|
||
}
|
||
|
||
/**
|
||
* Parses wpa_cli list_networks output and returns the id
|
||
* of a corresponding network SSID
|
||
*
|
||
* @param string $ssid
|
||
* @return integer id or null
|
||
*/
|
||
public function getNetworkIdBySSID($ssid) {
|
||
$iface = escapeshellarg($_SESSION['wifi_client_interface']);
|
||
$cmd = "sudo wpa_cli -i $iface list_networks";
|
||
$output = [];
|
||
exec($cmd, $output);
|
||
array_shift($output);
|
||
|
||
foreach ($output as $line) {
|
||
$columns = preg_split('/\t/', $line);
|
||
if (count($columns) >= 2 && trim($columns[1]) === trim($ssid)) {
|
||
return (int)$columns[0]; // return network ID
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
*
|
||
*/
|
||
public function networkExists($ssid, $collection)
|
||
{
|
||
foreach ($collection as $network) {
|
||
if ($network['ssid'] === $ssid) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Ensures /etc/wpa_supplicant/wpa_supplicant.conf exists with minimal safe contents
|
||
* Does not overwrite an existing file
|
||
*
|
||
* @throws \RuntimeException on permission or write failure
|
||
*/
|
||
public function ensureWpaSupplicant(): void
|
||
{
|
||
$confPath = '/etc/wpa_supplicant/wpa_supplicant.conf';
|
||
|
||
if (file_exists($confPath)) {
|
||
return;
|
||
}
|
||
|
||
$contents = <<<CONF
|
||
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
|
||
update_config=1
|
||
CONF;
|
||
|
||
$tmpFile = tempnam(sys_get_temp_dir(), 'wpa_conf_');
|
||
if ($tmpFile === false) {
|
||
throw new \RuntimeException("Failed to create temporary file for wpa_supplicant.conf");
|
||
}
|
||
|
||
file_put_contents($tmpFile, $contents);
|
||
chmod($tmpFile, 0600);
|
||
|
||
$cmd = escapeshellcmd("sudo cp $tmpFile $confPath");
|
||
exec($cmd, $output, $exitCode);
|
||
unlink($tmpFile);
|
||
|
||
if ($exitCode !== 0) {
|
||
throw new \RuntimeException("Failed to initialize wpa_supplicant.conf: " . implode("\n", $output));
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* Gets the operational status of a network interface
|
||
*
|
||
* @param string $interface network interface name
|
||
* @return string returns up, down, or unknown
|
||
*/
|
||
public function getInterfaceStatus(string $interface): string
|
||
{
|
||
exec('ip a show ' . escapeshellarg($interface), $output);
|
||
$outputGlued = implode(" ", $output);
|
||
$outputNormalized = preg_replace('/\s\s+/', ' ', $outputGlued);
|
||
|
||
if (preg_match('/state (UP|DOWN)/i', $outputNormalized, $matches)) {
|
||
return strtolower($matches[1]);
|
||
}
|
||
|
||
return 'unknown';
|
||
}
|
||
|
||
/**
|
||
* Connects to a network using wpa_cli
|
||
*
|
||
* @param string $interface network interface name
|
||
* @param int $netid network ID to connect to
|
||
* @return bool true on success, false on failure
|
||
*/
|
||
public function connectToNetwork(string $interface, int $netid): bool
|
||
{
|
||
$iface = escapeshellarg($interface);
|
||
|
||
$cmd = "sudo wpa_cli -i $iface select_network $netid";
|
||
$selectResult = shell_exec($cmd);
|
||
|
||
if ($selectResult === null || trim($selectResult) === "FAIL") {
|
||
return false;
|
||
}
|
||
sleep(3);
|
||
|
||
$cmd = "sudo wpa_cli -i $iface reassociate";
|
||
$reassociateResult = shell_exec($cmd);
|
||
|
||
if ($reassociateResult !== null) {
|
||
$trimmed = trim($reassociateResult);
|
||
if ($trimmed === "FAIL") {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Deletes a network from wpa_cli
|
||
*
|
||
* @param string $interface network interface name
|
||
* @param int $netid network ID to delete
|
||
* @return void
|
||
*/
|
||
public function deleteNetwork(string $interface, int $netid): void
|
||
{
|
||
$iface = escapeshellarg($interface);
|
||
|
||
exec("sudo wpa_cli -i $iface disconnect $netid");
|
||
exec("sudo wpa_cli -i $iface remove_network $netid");
|
||
}
|
||
|
||
/**
|
||
* Disconnects from a network using wpa_cli
|
||
*
|
||
* @param string $interface network interface name
|
||
* @param int $netid network ID to disconnect from
|
||
* @return void
|
||
*/
|
||
public function disconnectNetwork(string $interface, int $netid): void
|
||
{
|
||
$iface = escapeshellarg($interface);
|
||
|
||
exec("sudo wpa_cli -i $iface disconnect $netid");
|
||
exec("sudo wpa_cli -i $iface remove_network $netid");
|
||
sleep(2);
|
||
}
|
||
|
||
/**
|
||
* Updates/adds a network via wpa_cli
|
||
*
|
||
* @param string $interface network interface name
|
||
* @param string $ssid network SSID
|
||
* @param string $passphrase network passphrase
|
||
* @param string $protocol security protocol (OPEN or WPA)
|
||
* @return int|null network ID on success, null on failure
|
||
*/
|
||
public function updateNetwork(string $interface, string $ssid, string $passphrase, string $protocol = 'WPA'): ?int
|
||
{
|
||
$iface = escapeshellarg($interface);
|
||
$escapedSsid = escapeshellarg('"' . $ssid . '"');
|
||
|
||
$netid = shell_exec("sudo wpa_cli -i $iface add_network");
|
||
|
||
if ($netid === null || !is_numeric(trim($netid))) {
|
||
return null;
|
||
}
|
||
|
||
$netid = trim($netid);
|
||
$commands = [
|
||
"sudo wpa_cli -i $iface set_network $netid ssid $escapedSsid"
|
||
];
|
||
|
||
if ($protocol === self::SECURITY_OPEN) {
|
||
$commands[] = "sudo wpa_cli -i $iface set_network $netid key_mgmt NONE";
|
||
} else {
|
||
$escapedPsk = escapeshellarg('"' . $passphrase . '"');
|
||
$commands[] = "sudo wpa_cli -i $iface set_network $netid psk $escapedPsk";
|
||
}
|
||
|
||
$commands[] = "sudo wpa_cli -i $iface enable_network $netid";
|
||
|
||
foreach ($commands as $cmd) {
|
||
exec($cmd);
|
||
}
|
||
|
||
return (int)$netid;
|
||
}
|
||
|
||
/**
|
||
* Writes a wpa_supplicant configuration and applies it
|
||
*
|
||
* @param array $networks array of network configurations
|
||
* @param string $interface the network interface name
|
||
* @return array Array with 'success' (bool) and 'message' (string)
|
||
*/
|
||
public function writeWpaSupplicant(array $networks, string $interface): array
|
||
{
|
||
$wpa_file = fopen('/tmp/wifidata', 'w');
|
||
if (!$wpa_file) {
|
||
return ['success' => false, 'message' => 'Failed to update wifi settings'];
|
||
}
|
||
|
||
fwrite($wpa_file, 'ctrl_interface=DIR=' . RASPI_WPA_CTRL_INTERFACE . ' GROUP=netdev' . PHP_EOL);
|
||
fwrite($wpa_file, 'update_config=1' . PHP_EOL);
|
||
|
||
$ok = true;
|
||
foreach ($networks as $ssid => $network) {
|
||
if ($network['protocol'] === self::SECURITY_OPEN) {
|
||
fwrite($wpa_file, "network={".PHP_EOL);
|
||
fwrite($wpa_file, "\tssid=\"".$ssid."\"".PHP_EOL);
|
||
fwrite($wpa_file, "\tkey_mgmt=NONE".PHP_EOL);
|
||
fwrite($wpa_file, "\tscan_ssid=1".PHP_EOL);
|
||
if (array_key_exists('priority', $network)) {
|
||
fwrite($wpa_file, "\tpriority=".$network['priority'].PHP_EOL);
|
||
}
|
||
fwrite($wpa_file, "}".PHP_EOL);
|
||
} else {
|
||
if (strlen($network['passphrase']) >= 8 && strlen($network['passphrase']) <= 63) {
|
||
unset($wpa_passphrase);
|
||
unset($line);
|
||
exec('wpa_passphrase '. $this->ssid2utf8(escapeshellarg($ssid)) . ' ' . escapeshellarg($network['passphrase']), $wpa_passphrase);
|
||
foreach ($wpa_passphrase as $line) {
|
||
if (preg_match('/^\s*}\s*$/', $line)) {
|
||
if (array_key_exists('priority', $network)) {
|
||
fwrite($wpa_file, "\tpriority=".$network['priority'].PHP_EOL);
|
||
}
|
||
fwrite($wpa_file, $line.PHP_EOL);
|
||
} else {
|
||
if (preg_match('/\\\\x[0-9A-Fa-f]{2}/', $ssid) && strpos($line, "ssid=\"") !== false) {
|
||
fwrite($wpa_file, "\tssid=P\"".$ssid."\"".PHP_EOL);
|
||
} else {
|
||
fwrite($wpa_file, $line.PHP_EOL);
|
||
}
|
||
}
|
||
}
|
||
} elseif (strlen($network['passphrase']) == 0 && strlen($network['passkey']) == 64) {
|
||
$line = "\tpsk=" . $network['passkey'];
|
||
fwrite($wpa_file, "network={".PHP_EOL);
|
||
fwrite($wpa_file, "\tssid=\"".$ssid."\"".PHP_EOL);
|
||
fwrite($wpa_file, $line.PHP_EOL);
|
||
if (array_key_exists('priority', $network)) {
|
||
fwrite($wpa_file, "\tpriority=".$network['priority'].PHP_EOL);
|
||
}
|
||
fwrite($wpa_file, "}".PHP_EOL);
|
||
} else {
|
||
$ok = false;
|
||
fclose($wpa_file);
|
||
return ['success' => false, 'message' => 'WPA passphrase must be between 8 and 63 characters'];
|
||
}
|
||
}
|
||
}
|
||
|
||
fclose($wpa_file);
|
||
|
||
if ($ok) {
|
||
system('sudo cp /tmp/wifidata ' . RASPI_WPA_SUPPLICANT_CONFIG, $returnval);
|
||
if ($returnval == 0) {
|
||
exec('sudo wpa_cli -i ' . escapeshellarg($interface) . ' reconfigure', $reconfigure_out, $reconfigure_return);
|
||
if ($reconfigure_return == 0) {
|
||
return ['success' => true, 'message' => 'Wifi settings updated successfully'];
|
||
} else {
|
||
return ['success' => false, 'message' => 'Wifi settings updated but cannot restart (cannot execute "wpa_cli reconfigure")'];
|
||
}
|
||
} else {
|
||
return ['success' => false, 'message' => 'Wifi settings failed to be updated'];
|
||
}
|
||
}
|
||
|
||
return ['success' => false, 'message' => 'Unknown error'];
|
||
}
|
||
|
||
}
|