private Task <ProcessResult> FlushNetworkSequence(bool isEth0Changes, bool isWlan0Changes, NICProperties theEth0, NICProperties theWlan0) { return(Task.Run(async() => { await DHCPCD.UpdateResultAsync(new NICProperties[] { theEth0, theWlan0 }); await ProcessRunner.GetProcessResultAsync(c_SystemCtlCommand, "daemon-reload"); await ProcessRunner.GetProcessResultAsync(c_SystemCtlCommand, "stop dhcpcd.service"); if (isEth0Changes) { await ProcessRunner.GetProcessResultAsync(c_IPCommand, "addr flush dev eth0"); } if (isWlan0Changes) { await ProcessRunner.GetProcessResultAsync(c_IPCommand, "addr flush dev wlan0"); } await ProcessRunner.GetProcessResultAsync(c_SystemCtlCommand, "start dhcpcd.service"); await ProcessRunner.GetProcessResultAsync(c_SystemCtlCommand, "restart networking.service"); if (isWlan0Changes) { await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 reconfigure"); } return new ProcessResult(0, string.Empty, string.Empty); })); }
internal MemoryProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } Task <ProcessResult>[] Tasks = new Task <ProcessResult> [2]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_DFCommand, "-h"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_FreeCommand, "-h -t"); Task.WaitAll(Tasks); this.FreeDisk = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries) .Skip(1) .Select(line => line.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries)) .ToArray() : new string[0][]; this.FreeRam = Tasks[1].Result.Okay() ? Tasks[1].Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries) .Skip(1) .Select(line => line.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries)) .ToArray() : new string[0][]; LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.DiskFreeSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.RAMFreeSettingGetError); return(this); }
private Task <ProcessResult> SetWiFiSSIDPassphraseSequence(NetworkProperties theModel) { return(Task.Run(async() => { Log?.Invoke(EventLogEntryCodes.SSIDChanging, new string[] { theModel.NewSSID }); var AddNetworkTask = await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 add_network"); var NewNetworkId = AddNetworkTask.GetOutput().Trim(); ProcessResult SetSSID = await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 set_network " + NewNetworkId + " ssid '\"" + theModel.NewSSID + "\"'"); ProcessResult SetPassphrase; if (string.IsNullOrEmpty(theModel.NewPassphrase)) { SetPassphrase = await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 set_network " + NewNetworkId + " key_mgmt NONE"); } else { SetPassphrase = await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 set_network " + NewNetworkId + " psk '\"" + theModel.NewPassphrase + "\"'"); } await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 enable_network " + NewNetworkId); await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 save_config"); await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 reconfigure"); return new ProcessResult(0, string.Empty, string.Empty); })); }
internal bool DeleteWiFi(string id) { // TODO All Results aren't being catched. Task <ProcessResult> ScanTask = ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 list_networks"); ScanTask.Wait(); bool Result = ScanTask.Result.Okay(); if (Result) { string[] SSIDS = ScanTask.Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries) .Where(line => line.Contains(id)) .Select(line => line.Substring(0, line.IndexOf("\t"))) .ToArray(); if (SSIDS.Any()) { Task <Task <ProcessResult> > RemoveWiFi = ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 remove_network " + SSIDS[0]) .ContinueWith(async RemoveNetworkTask => await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 save_config")) .ContinueWith(async SaveConfigTask => await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 reconfigure")); RemoveWiFi.Wait(); Result = RemoveWiFi.Result.Result.Okay(); } else { Result = false; } } return(Result); }
internal void UpdateProperties(HomeProperties theProperties) { bool RestartHostAPd = false; IEnumerable <PropertyInfo> Properties = typeof(HomeProperties).GetProperties().Where(Property => Property.IsDefined(typeof(Models.Attributes.FileName), false)); foreach (PropertyInfo Property in Properties) { Models.Attributes.FileName FileNameAttribute = Property.GetCustomAttribute <Models.Attributes.FileName>(); if (FileNameAttribute != null) { string Old = Property.GetValue(this) as string; string New = Property.GetValue(theProperties) as string; if ((Old == null && New != null) || (!Old.Equals(New, StringComparison.Ordinal))) { Property.SetValue(this, New); RestartHostAPd = true; } } } Save(); if (m_RunningLinux && HostAPdEnabled != theProperties.HostAPdEnabled) { Task <ProcessResult> StartHostAPd = null; Task <ProcessResult> DisableHostAPd = null; if (theProperties.HostAPdEnabled) { Task <ProcessResult> EnableHostAPd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "enable " + c_HostAPdCommand); EnableHostAPd.Wait(); if (EnableHostAPd.Result.Okay()) { StartHostAPd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "start " + c_HostAPdCommand); StartHostAPd.Wait(); } } else { Task <ProcessResult> StopTimesyncd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "stop " + c_HostAPdCommand); StopTimesyncd.Wait(); if (StopTimesyncd.Result.Okay()) { DisableHostAPd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "disable " + c_HostAPdCommand); DisableHostAPd.Wait(); } } } else if (m_RunningLinux && HostAPdEnabled && RestartHostAPd) { Task <ProcessResult> Restart = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "restart " + c_HostAPdCommand); Restart.Wait(); } }
internal NetworkProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } Task <ProcessResult>[] Tasks = new Task <ProcessResult> [4]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/etc/hostname"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 get country"); Tasks[2] = GetSSIDs(); Tasks[3] = ProcessRunner.GetProcessResultAsync(c_IFConfigCommand); ReadResult ReadResult = DHCPCD.Read(); var Eth0 = ReadResult.Properties.FirstOrDefault(nic => nic.Id == c_Eth0); Eth0IPAddress = (Eth0 == null || Eth0.IPAddress == null) ? string.Empty : Eth0.IPAddress; Eth0IP6Address = (Eth0 == null || Eth0.IP6Address == null) ? string.Empty : Eth0.IP6Address; Eth0Routers = (Eth0 == null || Eth0.Routers == null) ? new string[0] : Eth0.Routers; Eth0DomainNameServers = (Eth0 == null || Eth0.DomainNameServers == null) ? new string[0] : Eth0.DomainNameServers; var Wlan0 = ReadResult.Properties.FirstOrDefault(nic => nic.Id == c_Wlan0); Wlan0IPAddress = (Wlan0 == null || Wlan0.IPAddress == null) ? string.Empty : Wlan0.IPAddress; Wlan0IP6Address = (Wlan0 == null || Wlan0.IP6Address == null) ? string.Empty : Wlan0.IP6Address; Wlan0Routers = (Wlan0 == null || Wlan0.Routers == null) ? new string[0] : Wlan0.Routers; Wlan0DomainNameServers = (Wlan0 == null || Wlan0.DomainNameServers == null) ? new string[0] : Wlan0.DomainNameServers; ReadResult = null; Task.WaitAll(Tasks); var WiFiCountryResult = Tasks[1].Result.GetOutput().TrimEnd(); WiFiCountrySet = WiFiCountryResult != c_WiFiCountryNotSet; HostName = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().TrimEnd() : string.Empty; WiFiCountry = WiFiCountrySet ? WiFiCountryResult : string.Empty; SSIDs = ProcessSSIDs(Tasks[2]); Interfaces = Tasks[3].Result.Okay() ? IFCONFIG.Parse(Tasks[3].Result.GetOutput()) : new NICInterface[0]; // Log only if errors have occured LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.HostNameSettingsGetError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.WiFiCountrySettingGetError); LoggingActions.LogTaskResult(Log, Tasks[2], EventLogEntryCodes.SSIDSettingsGetError); LoggingActions.LogTaskResult(Log, Tasks[3], EventLogEntryCodes.NICInterfacesGetError); return(this); }
private Task <ProcessResult> UnsetWiFiSequence() { return(Task.Run(async() => { ProcessResult Result = await ProcessRunner.GetProcessResultAsync(c_SedCommand, "-i '/country=/d' /etc/wpa_supplicant/wpa_supplicant.conf"); if (Result.Okay()) { Result = await ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 reconfigure"); } return Result; })); }
internal static void CheckRunningRaspberryPi() { if (Type.GetType("Mono.Runtime") != null) { isRunningMono = true; Task <ProcessResult> RaspberryPiModel = ProcessRunner.GetProcessResultAsync("cat", "/proc/device-tree/model"); RaspberryPiModel.Wait(); if (RaspberryPiModel.Result.Okay()) { isRunningRaspberryPi = true; } } }
public Response Get() { Task <ProcessResult> ScanTask = ProcessRunner.GetProcessResultAsync("iwlist", "wlan0 scan"); ScanTask.Wait(); const string c_SSIDLine = "ESSID:\""; string[] SSIDS = ScanTask.Result.Okay() ? ScanTask.Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries) .Where(line => line.Contains(c_SSIDLine)) .Select(line => line.Substring(line.IndexOf(c_SSIDLine) + c_SSIDLine.Length).TrimEnd('"')) .ToArray() : new string[0]; return(new Response { MediaType = "application/json", Model = SSIDS }); }
internal LocalisationProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } Task <ProcessResult>[] Tasks = new Task <ProcessResult> [9]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/usr/share/zoneinfo/iso3166.tab"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_WPACliCommand, "-i wlan0 get country"); Tasks[2] = ProcessRunner.GetProcessResultAsync(c_TimeDateControlCommand, "list-timezones"); Tasks[3] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/etc/timezone"); Tasks[4] = ProcessRunner.GetProcessResultAsync(c_DateCommand, "+%d/%m/%Y"); Tasks[5] = ProcessRunner.GetProcessResultAsync(c_DateCommand, "+%T"); Tasks[6] = ProcessRunner.GetProcessResultAsync(c_SystemCtlCommand, "is-active systemd-timesyncd"); Tasks[7] = ProcessRunner.GetProcessResultAsync(c_SystemCtlCommand, "is-active fake-hwclock"); Tasks[8] = ProcessRunner.GetProcessResultAsync(c_HardwareClockCommand, "-r"); Task.WaitAll(Tasks); WifiCountry = Tasks[1].Result.Okay() ? Tasks[1].Result.GetOutput() : string.Empty; WifiCountries = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries).Skip(25).Select(line => new string[] { line, line.StartsWith(WifiCountry) ? "selected=\"selected\"" : "" }).ToArray() : new string[0][]; TimeZone = Tasks[3].Result.Okay() ? Tasks[3].Result.GetOutput().TrimEnd() : string.Empty; TimeZones = Tasks[2].Result.Okay() ? Tasks[2].Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries).Skip(25).Select(line => new string[] { line, line.StartsWith(TimeZone) ? "selected=\"selected\"" : "" }).ToArray() : new string[0][]; Date = Tasks[4].Result.Okay() ? Tasks[4].Result.GetOutput().TrimEnd() : string.Empty; Time = Tasks[5].Result.Okay() ? Tasks[5].Result.GetOutput().TrimEnd() : string.Empty; TimeSyncdEnabled = Tasks[6].Result.Okay() ? Tasks[6].Result.GetOutput().TrimEnd().Equals(c_Active) : false; FakeHWClockEnabled = Tasks[7].Result.Okay() ? Tasks[7].Result.GetOutput().TrimEnd().Equals(c_Active) : false; HWClockPresent = Tasks[8].Result.Okay(); // Log only if errors have occured LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.WiFiCountriesSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.WiFiCountrySettingGetError); LoggingActions.LogTaskResult(Log, Tasks[2], EventLogEntryCodes.TimeZonesSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[3], EventLogEntryCodes.TimeZoneSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[4], EventLogEntryCodes.DateSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[5], EventLogEntryCodes.TimeSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[6], EventLogEntryCodes.TimeSyncdEnabledSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[7], EventLogEntryCodes.FakeHWClockEnabledSettingGetError); return(this); }
internal HatProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } if (Directory.Exists("/proc/device-tree/hat/")) { Task <ProcessResult>[] Tasks = new Task <ProcessResult> [5]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/proc/device-tree/hat/product"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/proc/device-tree/hat/product_id"); Tasks[2] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/proc/device-tree/hat/product_ver"); Tasks[3] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/proc/device-tree/hat/uuid"); Tasks[4] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/proc/device-tree/hat/vendor"); Task.WaitAll(Tasks); Product = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput() : string.Empty; ProductId = Tasks[1].Result.Okay() ? Tasks[1].Result.GetOutput() : string.Empty; ProductVersion = Tasks[2].Result.Okay() ? Tasks[2].Result.GetOutput() : string.Empty; UUID = Tasks[3].Result.Okay() ? Tasks[3].Result.GetOutput() : string.Empty; Vendor = Tasks[4].Result.Okay() ? Tasks[4].Result.GetOutput() : string.Empty; // Log only if errors have occured LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.HATSettingsGetProductError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.HATSettingsGetProductIdError); LoggingActions.LogTaskResult(Log, Tasks[2], EventLogEntryCodes.HATSettingsGetProductVersionError); LoggingActions.LogTaskResult(Log, Tasks[3], EventLogEntryCodes.HATSettingsGetUUIDError); LoggingActions.LogTaskResult(Log, Tasks[4], EventLogEntryCodes.HATSettingsGetVendorError); } else { Product = string.Empty; ProductId = string.Empty; ProductVersion = string.Empty; UUID = string.Empty; Vendor = string.Empty; } return(this); }
internal InterfacingProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } Task <ProcessResult>[] Tasks = new Task <ProcessResult> [8]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_camera"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_ssh"); Tasks[2] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_vnc"); Tasks[3] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_spi"); Tasks[4] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_i2c"); Tasks[5] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_serial"); Tasks[6] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_onewire"); Tasks[7] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_rgpio"); Task.WaitAll(Tasks); this.Camera = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.SSH = Tasks[1].Result.Okay() ? Tasks[1].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.VNC = Tasks[2].Result.Okay() ? Tasks[2].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.SPI = Tasks[3].Result.Okay() ? Tasks[3].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.I2C = Tasks[4].Result.Okay() ? Tasks[4].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.Serial = Tasks[5].Result.Okay() ? Tasks[5].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.OneWire = Tasks[6].Result.Okay() ? Tasks[6].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; this.RemoteGPIO = Tasks[7].Result.Okay() ? Tasks[7].Result.GetOutput().TrimEnd().Equals(c_Enabled) : false; // Log only if errors have occured LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.CameraSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.SSHSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[2], EventLogEntryCodes.VNCSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[3], EventLogEntryCodes.SPISettingGetError); LoggingActions.LogTaskResult(Log, Tasks[4], EventLogEntryCodes.I2CSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[5], EventLogEntryCodes.SerialSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[6], EventLogEntryCodes.OneWireSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[7], EventLogEntryCodes.RemoteGPIOSettingGetError); return(this); }
private bool isRunningLinux() { if (Type.GetType("Mono.Runtime") != null) { try { Task <ProcessResult> RaspberryPiModel = ProcessRunner.GetProcessResultAsync("cat", "/proc/device-tree/model"); RaspberryPiModel.Wait(); return(RaspberryPiModel.Result.Okay()); } catch { return(false); } } else { return(false); } }
internal HomeProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } Task <ProcessResult>[] Tasks = new Task <ProcessResult> [7]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/proc/device-tree/model"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/etc/debian_version"); Tasks[2] = ProcessRunner.GetProcessResultAsync(c_CatCommand, "/etc/hostname"); Tasks[3] = ProcessRunner.GetProcessResultAsync(c_DateCommand); Tasks[4] = GetGPUTemperature(); Tasks[5] = GetCPUTemperature(); Tasks[6] = GetDiskSpacePercentage(); Task.WaitAll(Tasks); RaspberryPiModel = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().TrimEnd() : string.Empty; OSVersion = Tasks[1].Result.Okay() ? Tasks[1].Result.GetOutput().TrimEnd() : string.Empty; HostName = Tasks[2].Result.Okay() ? Tasks[2].Result.GetOutput().TrimEnd() : string.Empty; Date = Tasks[3].Result.Okay() ? Tasks[3].Result.GetOutput().TrimEnd() : string.Empty; GPUTemperature = ProcessGPUTemperature(Tasks[4]); CPUTemperature = ProcessCPUTemperature(Tasks[5]); FreeDiskPercentage = ProcessDiskSpacePercentage(Tasks[6]); // Log only if errors have occured LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.RaspberryPiModelSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.DebianVersionSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[2], EventLogEntryCodes.HostNameSettingsGetError); LoggingActions.LogTaskResult(Log, Tasks[3], EventLogEntryCodes.DateTimeSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[4], EventLogEntryCodes.GPUTemperatureSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[5], EventLogEntryCodes.CPUTemperatureSettingGetError); LoggingActions.LogTaskResult(Log, Tasks[6], EventLogEntryCodes.DiskFreeSettingGetError); return(this); }
internal BootProperties RepopulateAndGetProperties() { if (!Utils.Hardware.isRunningRaspberryPi) { return(this); } Task <ProcessResult>[] Tasks = new Task <ProcessResult> [2]; Tasks[0] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_boot_wait"); Tasks[1] = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint get_boot_splash"); Task.WaitAll(Tasks); NetworkWait = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().TrimEnd().Equals("0") : false; SplashScreen = Tasks[1].Result.Okay() ? Tasks[1].Result.GetOutput().TrimEnd().Equals("0") : false; // Log only if errors have occured LoggingActions.LogTaskResult(Log, Tasks[0], EventLogEntryCodes.NetworkWaitSettingsGetError); LoggingActions.LogTaskResult(Log, Tasks[1], EventLogEntryCodes.SplashScreenSettingsGetError); return(this); }
/// <summary> /// Restarts the Pi. Must be running as SU. /// </summary> /// <returns>The process result.</returns> public async Task <ProcessResultModel> Restart() { var piResult = await ProcessRunner.GetProcessResultAsync("reboot", null, null); return(this._mapper.Map <ProcessResultModel>(piResult)); }
internal static Task <ProcessResult> GetDiskSpacePercentage() { return(ProcessRunner.GetProcessResultAsync(c_DFCommand, "-h")); }
internal static Task <ProcessResult> GetCPUTemperature() { return(ProcessRunner.GetProcessResultAsync(c_CatCommand, "/sys/class/thermal/thermal_zone0/temp")); }
internal static Task <ProcessResult> GetGPUTemperature() { return(ProcessRunner.GetProcessResultAsync(c_VCGenCommand, "measure_temp")); }
/// <summary> /// Restarts the Pi. Must be running as SU /// </summary> /// <returns>The process result</returns> public static async Task <ProcessResult> RestartAsync() => await ProcessRunner.GetProcessResultAsync("reboot");
internal HomeProperties RepopulateAndGetProperties() { List <PropertyInfo> Properties = GetType().GetProperties().Where(prop => prop.IsDefined(typeof(Models.Attributes.FileName), false)).ToList(); SetDefaults(Properties); if (m_RunningLinux) { Task <ProcessResult>[] Tasks = new Task <ProcessResult> [1]; Tasks[0] = ProcessRunner.GetProcessResultAsync("systemctl", "is-active hostapd"); Task.WaitAll(Tasks); HostAPdEnabled = Tasks[0].Result.Okay() ? Tasks[0].Result.GetOutput().TrimEnd().Equals("active") : false; } if (!File.Exists(Location)) { return(this); } List <string> OrphanLinesList = new List <string>(); using (System.IO.StreamReader file = new System.IO.StreamReader(Location)) { string line; while ((line = file.ReadLine()) != null) { string[] KeyValue = line.Split('='); PropertyInfo LinkedProperty = null; if (KeyValue.Length == 2 && (!KeyValue[0].Contains("#"))) { string Key = KeyValue[0].Trim(); foreach (PropertyInfo Property in Properties) { Models.Attributes.FileName FileNameAttribute = Property.GetCustomAttribute <Models.Attributes.FileName>(); if (FileNameAttribute != null && Key.Equals(FileNameAttribute.Name, StringComparison.OrdinalIgnoreCase)) { Property.SetValue(this, KeyValue[1]); LinkedProperty = Property; break; } } if (LinkedProperty != null) { Properties.Remove(LinkedProperty); } else { OrphanLinesList.Add(line); } } else { OrphanLinesList.Add(line); } } } OrphanLines = OrphanLinesList.ToArray(); return(this); }
internal void UpdateProperties(LocalisationProperties theModel) { List <Task <ProcessResult> > Tasks = new List <Task <ProcessResult> >(); RepopulateAndGetProperties(); bool AskToRestart = false; Task <ProcessResult> StartTimesyncd = null; Task <ProcessResult> DisableTimesyncd = null; if (TimeSyncdEnabled != theModel.TimeSyncdEnabled) { LoggingActions.LogTaskAction(Log, theModel.TimeSyncdEnabled, EventLogEntryCodes.TimesyncdEnabling, EventLogEntryCodes.TimesyncdStopping); if (theModel.TimeSyncdEnabled) { Task <ProcessResult> EnableTimesyncd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "enable systemd-timesyncd"); EnableTimesyncd.Wait(); LoggingActions.LogTaskResult(Log, EnableTimesyncd, EventLogEntryCodes.TimesyncdEnabled, EventLogEntryCodes.TimesyncdEnablingError); if (EnableTimesyncd.Result.Okay()) { Log?.Invoke(EventLogEntryCodes.TimesyncdStarting, null); StartTimesyncd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "start systemd-timesyncd"); Tasks.Add(StartTimesyncd); } } else { Task <ProcessResult> StopTimesyncd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "stop systemd-timesyncd"); StopTimesyncd.Wait(); LoggingActions.LogTaskResult(Log, StopTimesyncd, EventLogEntryCodes.TimesyncdStopped, EventLogEntryCodes.TimesyncdStoppingError); if (StopTimesyncd.Result.Okay()) { Log?.Invoke(EventLogEntryCodes.TimesyncdDisabling, null); DisableTimesyncd = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "disable systemd-timesyncd"); Tasks.Add(DisableTimesyncd); } } } Task <ProcessResult> StartFakeHWClock = null; Task <ProcessResult> DisableFakeHWClock = null; if (FakeHWClockEnabled != theModel.FakeHWClockEnabled) { LoggingActions.LogTaskAction(Log, theModel.FakeHWClockEnabled, EventLogEntryCodes.FakeHwClockEnabling, EventLogEntryCodes.FakeHwClockStopping); if (theModel.FakeHWClockEnabled) { Task <ProcessResult> EnableFakeHWClock = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "enable fake-hwclock"); EnableFakeHWClock.Wait(); LoggingActions.LogTaskResult(Log, EnableFakeHWClock, EventLogEntryCodes.FakeHwClockEnabled, EventLogEntryCodes.FakeHwClockEnablingError); if (EnableFakeHWClock.Result.Okay()) { Log?.Invoke(EventLogEntryCodes.TimesyncdEnabling, null); StartFakeHWClock = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "start fake-hwclock"); Tasks.Add(StartFakeHWClock); } } else { Task <ProcessResult> StopFakeHWClock = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "stop fake-hwclock"); StopFakeHWClock.Wait(); LoggingActions.LogTaskResult(Log, StopFakeHWClock, EventLogEntryCodes.FakeHwClockStopped, EventLogEntryCodes.FakeHwClockStoppingError); if (StopFakeHWClock.Result.Okay()) { Log?.Invoke(EventLogEntryCodes.FakeHwClockDisabling, null); DisableFakeHWClock = ProcessRunner.GetProcessResultAsync(c_LinuxSystemControlCommand, "disable fake-hwclock"); Tasks.Add(DisableFakeHWClock); } } } Task <ProcessResult> SetTimeZone = null; if (TimeZone != theModel.TimeZone) { Log?.Invoke(EventLogEntryCodes.TimeZoneSetting, new string[] { theModel.TimeZone }); SetTimeZone = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_change_timezone " + theModel.TimeZone); Tasks.Add(SetTimeZone); } Task <ProcessResult> SetWifiCountry = null; if (WifiCountry != theModel.WifiCountry) { if (theModel.WifiCountry == string.Empty) { AskToRestart = true; Log?.Invoke(EventLogEntryCodes.WifiCountrySetting, new string[] { "None" }); SetWifiCountry = UnsetWiFiSequence(); Tasks.Add(SetWifiCountry); } else { AskToRestart = true; Log?.Invoke(EventLogEntryCodes.WifiCountrySetting, new string[] { theModel.WifiCountry }); SetWifiCountry = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_wifi_country " + theModel.WifiCountry); Tasks.Add(SetWifiCountry); } } Task <ProcessResult> SetDate = null; if (theModel.SetDate) { DateTime DateConvert = DateTime.ParseExact(theModel.Date.Replace("/", ""), "ddMMyyyy", CultureInfo.InvariantCulture); string DateCommand = "+%Y%m%d -s \"" + DateConvert.ToString("yyyyMMdd") + "\""; Log?.Invoke(EventLogEntryCodes.DateSetting, new string[] { "date " + DateCommand }); SetDate = ProcessRunner.GetProcessResultAsync(c_DateCommand, DateCommand); Tasks.Add(SetDate); } Task <ProcessResult> SetTime = null; if (theModel.SetTime) { string TimeCommand = "+%T -s \"" + theModel.Time + "\""; Log?.Invoke(EventLogEntryCodes.TimeSetting, new string[] { "date " + TimeCommand }); SetTime = ProcessRunner.GetProcessResultAsync(c_DateCommand, TimeCommand); Tasks.Add(SetTime); } if (AskToRestart) { RestartDue?.Invoke(); } Task.WaitAll(Tasks.ToArray()); Task <ProcessResult> SyncRTC = null; if (HWClockPresent && (theModel.SetTime || theModel.SetDate || (theModel.TimeSyncdEnabled && !TimeSyncdEnabled)) && theModel.HWClockPresent) { Log?.Invoke(EventLogEntryCodes.RTCSyncing, null); SyncRTC = ProcessRunner.GetProcessResultAsync(c_HardwareClockCommand, "-w"); SyncRTC.Wait(); } // Check if Tasks have completed Okay and Log result LoggingActions.LogTaskResult(Log, StartTimesyncd, EventLogEntryCodes.TimesyncdStarted, EventLogEntryCodes.TimesyncdStartingError); LoggingActions.LogTaskResult(Log, DisableTimesyncd, EventLogEntryCodes.TimesyncdDisabled, EventLogEntryCodes.TimesyncdDisablingError); LoggingActions.LogTaskResult(Log, StartFakeHWClock, EventLogEntryCodes.FakeHwClockStarted, EventLogEntryCodes.FakeHwClockStartingError); LoggingActions.LogTaskResult(Log, DisableFakeHWClock, EventLogEntryCodes.FakeHwClockDisabled, EventLogEntryCodes.FakeHwClockDisablingError); LoggingActions.LogTaskResult(Log, SetTimeZone, EventLogEntryCodes.TimeZoneSet, EventLogEntryCodes.TimeZoneSettingError); LoggingActions.LogTaskResult(Log, SetWifiCountry, EventLogEntryCodes.WifiCountrySet, EventLogEntryCodes.WifiCountrySettingError); LoggingActions.LogTaskResult(Log, SetDate, EventLogEntryCodes.DateSet, EventLogEntryCodes.DateSettingError); LoggingActions.LogTaskResult(Log, SetTime, EventLogEntryCodes.TimeSet, EventLogEntryCodes.TimeSettingError); LoggingActions.LogTaskResult(Log, SyncRTC, EventLogEntryCodes.RTCSynced, EventLogEntryCodes.RTCSyncError); }
/// <summary> /// Restarts the Pi. Must be running as SU /// </summary> /// <returns>The process result</returns> public static async Task <ProcessResult> RestartAsync() { return(await ProcessRunner.GetProcessResultAsync("reboot")); }
internal void UpdateProperties(InterfacingProperties theModel) { List <Task <ProcessResult> > Tasks = new List <Task <ProcessResult> >(); bool AskToRestart = false; RepopulateAndGetProperties(); Task <ProcessResult> SetCamera = null; if (Camera != theModel.Camera) { AskToRestart = true; LoggingActions.LogTaskAction(Log, theModel.Camera, EventLogEntryCodes.CameraSettingEnabling, EventLogEntryCodes.CameraSettingDisabling); SetCamera = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_camera " + (theModel.Camera ? c_Enabled : c_Disabled)); Tasks.Add(SetCamera); } Task <ProcessResult> SetSSH = null; if (SSH != theModel.SSH) { LoggingActions.LogTaskAction(Log, theModel.SSH, EventLogEntryCodes.SSHSettingEnabling, EventLogEntryCodes.SSHSettingDisabling); SetSSH = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_ssh " + (theModel.SSH ? c_Enabled : c_Disabled)); Tasks.Add(SetSSH); } Task <ProcessResult> SetVNC = null; if (VNC != theModel.VNC) { LoggingActions.LogTaskAction(Log, theModel.VNC, EventLogEntryCodes.VNCSettingEnabling, EventLogEntryCodes.VNCSettingDisabling); SetVNC = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_vnc " + (theModel.VNC ? c_Enabled : c_Disabled)); Tasks.Add(SetVNC); } Task <ProcessResult> SetSPI = null; if (SPI != theModel.SPI) { LoggingActions.LogTaskAction(Log, theModel.SPI, EventLogEntryCodes.SPISettingEnabling, EventLogEntryCodes.SPISettingDisabling); SetSPI = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_spi " + (theModel.SPI ? c_Enabled : c_Disabled)); Tasks.Add(SetSPI); } Task <ProcessResult> SetI2C = null; if (I2C != theModel.I2C) { LoggingActions.LogTaskAction(Log, theModel.I2C, EventLogEntryCodes.I2CSettingEnabling, EventLogEntryCodes.I2CSettingDisabling); SetI2C = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_i2c " + (theModel.I2C ? c_Enabled : c_Disabled)); Tasks.Add(SetI2C); } Task <ProcessResult> SetSerial = null; if (Serial != theModel.Serial) { AskToRestart = true; LoggingActions.LogTaskAction(Log, theModel.Serial, EventLogEntryCodes.SerialSettingEnabling, EventLogEntryCodes.SerialSettingDisabling); SetSerial = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_serial " + (theModel.Serial ? c_Enabled : c_Disabled)); Tasks.Add(SetSerial); } Task <ProcessResult> SetOneWire = null; if (OneWire != theModel.OneWire) { AskToRestart = true; LoggingActions.LogTaskAction(Log, theModel.OneWire, EventLogEntryCodes.OneWireSettingEnabling, EventLogEntryCodes.OneWireSettingDisabling); SetOneWire = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_onewire " + (theModel.OneWire ? c_Enabled : c_Disabled)); Tasks.Add(SetOneWire); } Task <ProcessResult> SetRemoteGPIO = null; if (RemoteGPIO != theModel.RemoteGPIO) { LoggingActions.LogTaskAction(Log, theModel.RemoteGPIO, EventLogEntryCodes.RemoteGPIOSettingEnabling, EventLogEntryCodes.RemoteGPIOSettingDisabling); SetRemoteGPIO = ProcessRunner.GetProcessResultAsync(c_LinuxRaspconfigCommand, "nonint do_rgpio " + (theModel.RemoteGPIO ? c_Enabled : c_Disabled)); Tasks.Add(SetRemoteGPIO); } Task.WaitAll(Tasks.ToArray()); if (AskToRestart) { RestartDue?.Invoke(); } // Check if Tasks have completed Okay and Log result LoggingActions.LogTaskResult(Log, SetCamera, theModel.Camera, EventLogEntryCodes.CameraSettingEnabled, EventLogEntryCodes.CameraSettingDisabled, EventLogEntryCodes.CameraSettingError); LoggingActions.LogTaskResult(Log, SetSSH, theModel.SSH, EventLogEntryCodes.SSHSettingEnabled, EventLogEntryCodes.SSHSettingDisabled, EventLogEntryCodes.SSHSettingError); LoggingActions.LogTaskResult(Log, SetVNC, theModel.VNC, EventLogEntryCodes.VNCSettingEnabled, EventLogEntryCodes.VNCSettingDisabled, EventLogEntryCodes.VNCSettingError); LoggingActions.LogTaskResult(Log, SetSPI, theModel.SPI, EventLogEntryCodes.SPISettingEnabled, EventLogEntryCodes.SPISettingDisabled, EventLogEntryCodes.SPISettingError); LoggingActions.LogTaskResult(Log, SetI2C, theModel.I2C, EventLogEntryCodes.I2CSettingEnabled, EventLogEntryCodes.I2CSettingDisabled, EventLogEntryCodes.I2CSettingError); LoggingActions.LogTaskResult(Log, SetSerial, theModel.Serial, EventLogEntryCodes.SerialSettingEnabled, EventLogEntryCodes.SerialSettingDisabled, EventLogEntryCodes.SerialSettingError); LoggingActions.LogTaskResult(Log, SetOneWire, theModel.OneWire, EventLogEntryCodes.OneWireSettingEnabled, EventLogEntryCodes.OneWireSettingDisabled, EventLogEntryCodes.OneWireSettingError); LoggingActions.LogTaskResult(Log, SetRemoteGPIO, theModel.RemoteGPIO, EventLogEntryCodes.RemoteGPIOSettingEnabled, EventLogEntryCodes.RemoteGPIOSettingDisabled, EventLogEntryCodes.RemoteGPIOSettingError); }
/// <summary> /// Halts the Pi. Must be running as SU /// </summary> /// <returns>The process result</returns> public static async Task <ProcessResult> ShutdownAsync() => await ProcessRunner.GetProcessResultAsync("halt");
/// <summary> /// Restarts the Pi. Must be running as SU. /// </summary> /// <returns>The process result.</returns> public static Task <ProcessResult> RestartAsync() => ProcessRunner.GetProcessResultAsync("reboot", null, null);
/// <summary> /// Halts the Pi. Must be running as SU. /// </summary> /// <returns>The process result.</returns> public static Task <ProcessResult> ShutdownAsync() => ProcessRunner.GetProcessResultAsync("halt", null, null);
/// <summary> /// Halts the Pi. Must be running as SU. /// </summary> /// <returns>The process result.</returns> public async Task <ProcessResultModel> Shutdown() { var piResult = await ProcessRunner.GetProcessResultAsync("halt", null, null); return(this._mapper.Map <ProcessResultModel>(piResult)); }
public Response Post(UsersProperties theModel) { if (string.IsNullOrEmpty(theModel.Username)) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=1") }); } if (string.IsNullOrEmpty(theModel.OldPassword)) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=2") }); } if (theModel.NewPassword != theModel.NewPasswordCheck) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=3") }); } if (string.IsNullOrEmpty(theModel.NewPassword)) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=4") }); } Task <ProcessResult> UserEntries = ProcessRunner.GetProcessResultAsync("grep", "^" + theModel.Username + " /etc/shadow"); UserEntries.Wait(); var CommandResultLines = UserEntries.Result.GetOutput().Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries) .Select(line => line.TrimEnd()) .ToArray(); if (CommandResultLines.Length == 0) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=5") }); } if (CommandResultLines.Length > 1) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=6") }); } // Format of Line is Username$AlgorithmType$Salt$HashedPassword:OtherMeta string UserEntry = CommandResultLines[0]; const string Dollar = "$"; const string Colon = ":"; int StartIndex = UserEntry.IndexOf(Dollar); int EndHashAlgorithmTypeIndex = UserEntry.IndexOf(Dollar, StartIndex + Dollar.Length); int EndSaltIndex = UserEntry.IndexOf(Dollar, EndHashAlgorithmTypeIndex + Dollar.Length); int EndHashIndex = UserEntry.IndexOf(Colon, StartIndex + Dollar.Length); string HashAlgorithmType = UserEntry.Substring(StartIndex, EndHashAlgorithmTypeIndex - StartIndex + Dollar.Length); // Existing Hash, including the Algorithm Type $6$, the Salt and the Hash string ExistingHash = UserEntry.Substring(StartIndex, EndHashIndex - StartIndex); string Salt = UserEntry.Substring(EndHashAlgorithmTypeIndex + Dollar.Length, EndSaltIndex - EndHashAlgorithmTypeIndex - Dollar.Length); string NewHash = Linux.Crypt(theModel.OldPassword, HashAlgorithmType + Salt + Dollar); if (ExistingHash != NewHash) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=7") }); } Task <ProcessResult> ChangePassword = ProcessRunner.GetProcessResultAsync("bash", "-c \"echo '" + theModel.Username + ":" + theModel.NewPassword + "' | chpasswd\""); ChangePassword.Wait(); if (ChangePassword.Result.Okay()) { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=10") }); } else { return(new Response { StatusCode = System.Net.HttpStatusCode.Moved, Location = new Uri(RemoveOldQueryString(Context.Request.AbsoluteUri) + "?msg=9") }); } }
/// <summary> /// Halts the Pi. Must be running as SU /// </summary> /// <returns>The process result</returns> public static async Task <ProcessResult> ShutdownAsync() { return(await ProcessRunner.GetProcessResultAsync("halt")); }