public static string DeleteTunnelPointToPointIpv4(string interfaceName)
{
var cmd = $"ip tunnel del {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string SetBridgePortPriority(string bridgeName, string port, string priority)
{
var cmd = $"brctl setportprio {bridgeName} {port} {priority} set port priority";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string DeleteNeighborsIpv6(string address, string layerAddress, string interfaceName)
{
var cmd = $"ip -6 neigh del {address} lladdr {layerAddress} dev {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string DeleteNetworkInterfaceToBridge(string bridgeName, string interfaceName)
{
var cmd = $"brctl delif {bridgeName} {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string FlushConfigurationIpv6()
{
var cmd = $"ip addr flush dynamic";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string AddTunnelPointToPointIpv4(string interfaceName, string ttl, string foreignTunnel, string address)
{
var cmd = $"ip tunnel add {interfaceName} mode sit ttl {ttl} remote {foreignTunnel} local {address}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string DisableStpOnBridge(string bridgeName)
{
var cmd = $"brctl stp {bridgeName} off";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string AddNat(string address, string viaAddress)
{
var cmd = $"ip route add nat {address} via {viaAddress}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string DisableInterface(string interfaceName)
{
var cmd = $"ip link set {interfaceName} down";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string AddMultipathRoute(string net1, string net2)
{
var cmd = $"ip route add default scope global nexthop dev {net1} nexthop dev {net2}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string SetBridgePathCost(string bridgeName, string path, string cost)
{
var cmd = $"brctl setpathcost {bridgeName} {path} {cost} set path cost";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string DeleteBridgeName(string bridgeName)
{
var cmd = $"brctl delbr {bridgeName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string AddNewAddressIpv6(string address, string interfaceName)
{
var cmd = $"ip -6 addr add {address} dev {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static void AddNftRule(string prefix, string rule)
{
ConfigManagement.AddCommandsBundle($"{prefix} {rule}");
if (rule.Length > 0)
{
Terminal.Terminal.Execute($"{prefix} {rule}");
}
}
public static string FlushConfigurationIpv4(string interfaceName = null)
{
var i = interfaceName == null ? "label \"eth *\"" : "dev {interfaceName}";
var cmd = $"ip addr flush {i}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
/// <summary>
/// Start the IR Server plugin.
/// </summary>
/// <returns>true if successful, otherwise false.</returns>
public override void Start()
{
_config = new Config();
ConfigManagement.LoadSettings(ref _config);
RegisterDeviceNotification();
StartListener();
}
public static string DeleteRouteIpv4(string gateway, string destination)
{
var cmd = destination == null ?
$"ip route del default via {gateway}" :
$"ip route del {destination} via {gateway}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public static string DeleteAddressIpv4(string address, string range, string interfaceName, string broadcast)
{
var cmd = broadcast == "" ?
$"ip addr del {address}/{range} dev {interfaceName}" :
$"ip addr del {address}/{range} broadcast {address} dev {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
public Main()
{
InitializeComponent();
CheckForIllegalCrossThreadCalls = false;
Lessons = new List <Lesson>();
Manager = new Database.General();
ZoomEntities = new ZoomEntities();
BGWorker = new BGWorker(ref backgroundWorker1);
Cfg = new ConfigManagement();
}
public static void Main()
{
CreateAndCheckEventLogSource();
#region Config
var config = ConfigManagement.LoadConfig();
ConfigManagement.SaveConfig(); //Create one with default loaded values
#endregion
#region Chose language
//Set the language of the threads
CultureInfo cultureInfo;
if (string.IsNullOrWhiteSpace(config.Language) || config.Language == "windows")
{
cultureInfo = CultureInfo.CurrentCulture;
}
else
{
try
{
cultureInfo = new CultureInfo(config.Language);
}
catch
{
cultureInfo = CultureInfo.CurrentCulture;
}
}
Thread.CurrentThread.CurrentCulture = cultureInfo;
Thread.CurrentThread.CurrentUICulture = cultureInfo;
CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
#endregion
#region AutoUpdater
Updater.Updater.PersistenceProvider = new RegistryMachinePersistenceProvider(DaemonMasterAppRegPath);
if (!ConfigManagement.GetConfig.DisableCheckForUpdates)
{
_ = Updater.Updater.StartAsync("https://github.com/TWC-Software/DaemonMaster");
}
#endregion
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// MAINWINDOW //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
var app = new App();
var mainWindow = new MainWindow();
app.Run(mainWindow);
}
/// <summary>
/// Configure the IR Server plugin.
/// </summary>
public void Configure(IWin32Window owner)
{
_config = new Config();
ConfigManagement.LoadSettings(ref _config);
ConfigurationDialog configDialog = new ConfigurationDialog();
configDialog.LearnTimeout = _config.LearnTimeout;
configDialog.DisableMceServices = _config._disableMceServices;
configDialog.EnableRemote = _config.EnableRemoteInput;
configDialog.UseSystemRatesForRemote = _config.UseSystemRatesRemote;
configDialog.RemoteRepeatDelay = _config.RemoteFirstRepeat;
configDialog.RemoteHeldDelay = _config.RemoteHeldRepeats;
configDialog.DisableAutomaticButtons = _config._disableAutomaticButtons;
configDialog.EnableKeyboard = _config.EnableKeyboardInput;
configDialog.UseSystemRatesForKeyboard = _config.UseSystemRatesKeyboard;
configDialog.KeyboardRepeatDelay = _config.KeyboardFirstRepeat;
configDialog.KeyboardHeldDelay = _config.KeyboardHeldRepeats;
configDialog.HandleKeyboardLocal = _config.HandleKeyboardLocally;
configDialog.UseQwertzLayout = _config.UseQwertzLayout;
configDialog.EnableMouse = _config.EnableMouseInput;
configDialog.HandleMouseLocal = _config.HandleMouseLocally;
configDialog.MouseSensitivity = _config.MouseSensitivity;
if (configDialog.ShowDialog(owner) == DialogResult.OK)
{
_config.LearnTimeout = configDialog.LearnTimeout;
_config._disableMceServices = configDialog.DisableMceServices;
_config.EnableRemoteInput = configDialog.EnableRemote;
_config.UseSystemRatesRemote = configDialog.UseSystemRatesForRemote;
_config.RemoteFirstRepeat = configDialog.RemoteRepeatDelay;
_config.RemoteHeldRepeats = configDialog.RemoteHeldDelay;
_config._disableAutomaticButtons = configDialog.DisableAutomaticButtons;
_config.EnableKeyboardInput = configDialog.EnableKeyboard;
_config.UseSystemRatesKeyboard = configDialog.UseSystemRatesForKeyboard;
_config.KeyboardFirstRepeat = configDialog.KeyboardRepeatDelay;
_config.KeyboardHeldRepeats = configDialog.KeyboardHeldDelay;
_config.HandleKeyboardLocally = configDialog.HandleKeyboardLocal;
_config.EnableMouseInput = configDialog.EnableMouse;
_config.HandleMouseLocally = configDialog.HandleMouseLocal;
_config.MouseSensitivity = configDialog.MouseSensitivity;
ConfigManagement.SaveSettings(_config);
}
}
public static void ExportNewFirewallConfiguration()
{
var template = $"{Parameter.RepoConfig}/antd.firewall.template.conf";
var text = Terminal.Terminal.Execute($"cat {template}");
foreach (var values in FirewallLists.GetAll())
{
var replace = text.Replace(values.TemplateWord, ConfigManagement.SupposeCommandReplacement(values.ReplaceTemplateValues));
text = replace;
}
var newConfFile = GetLastFileName();
File.WriteAllText(newConfFile, text);
}
public static string DeleteRouteIpv6Interface(string interfaceName, string gateway = null)
{
if (gateway == null)
{
var cmd = $"ip -6 route del default dev {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
else
{
var cmd = $"ip -6 route del {gateway} dev {interfaceName}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
}
public static string DeleteRouteIpv6Gateway(string address, string gateway = null)
{
if (gateway == null)
{
var cmd = $"ip -6 route del default via {address}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
else
{
var cmd = $"ip -6 route del {gateway} via {address}";
ConfigManagement.AddCommandsBundle(cmd);
return(Terminal.Terminal.Execute(cmd));
}
}
/// <summary>
/// Start the receiver.
/// </summary>
private void Start_Receiver()
{
Debug.Open("Philips MCE USB IR Receiver- Spinel plus.log");
Debug.WriteLine("Start_Receiver()");
_config = new Config();
ConfigManagement.LoadSettings(ref _config);
_firstRepeatDelay = _config.FirstRepeatDelay;
_heldRepeatDelay = _config.HeldRepeatDelay;
if (_config.UseSystemRatesDelay)
{
_firstRepeatDelay = 250 + (SystemInformation.KeyboardDelay * 250);
_heldRepeatDelay = (int)(1000.0 / (2.5 + (SystemInformation.KeyboardSpeed * 0.888)));
}
// create receiver Window
_receiverWindow = new ReceiverWindow("Philips MCE USB IR Receiver- Spinel plus Receiver");
_receiverWindow.ProcMsg += ProcMessage;
// collect devices
_deviceList = new List <RawInput.RAWINPUTDEVICE>();
RawInput.RAWINPUTDEVICE _device;
foreach (Device device in supportedDevices)
{
foreach (DeviceDetails details in device.DeviceDetails)
{
_device = new RawInput.RAWINPUTDEVICE();
_device.usUsage = details.Usage;
_device.usUsagePage = details.UsagePage;
_device.dwFlags = RawInput.RawInputDeviceFlags.InputSink;
_device.hwndTarget = _receiverWindow.Handle;
_deviceList.Add(_device);
}
}
if (!RegisterForRawInput(_deviceList.ToArray()))
{
Debug.WriteLine("ERROR: Failed to register for HID Raw input");
throw new InvalidOperationException("Failed to register for HID Raw input");
}
Debug.WriteLine("Start_Receiver(): completed");
}
public static void DeleteNftRule(string guid)
{
var command = ConfigManagement.GetCommandsBundle().Where(_ => _.Guid == guid).Select(_ => _.Command).FirstOrDefault();
if (command == null || command.Length <= 0)
{
return;
}
var chain = command.Split(' ')[4];
var hook = command.Split(' ')[5];
var checkTables = Terminal.Terminal.Execute($"nft list table {chain} -a | grep \"{command}\"");
if (checkTables.Length > 0)
{
var handle = checkTables.Split(' ').Last();
Terminal.Terminal.Execute($"nft delete rule {chain} {hook} handle {handle}");
}
ConfigManagement.DeleteCommandsBundle(guid);
}
public static void Main()
{
CreateAndCheckEventLogSource();
//Load and apply config
Config config = ConfigManagement.LoadConfig();
#region Chose language
//Set the language of the threads
CultureInfo cultureInfo;
if (string.IsNullOrWhiteSpace(config.Language) || config.Language == "windows")
{
cultureInfo = CultureInfo.CurrentCulture;
}
else
{
try
{
cultureInfo = new CultureInfo(config.Language);
}
catch
{
cultureInfo = CultureInfo.CurrentCulture;
}
}
Thread.CurrentThread.CurrentCulture = cultureInfo;
Thread.CurrentThread.CurrentUICulture = cultureInfo;
CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
#endregion
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// START //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
var app = new App();
var mainWindow = new MainWindow();
app.Run(mainWindow);
}
/// <summary>
/// Configure the IR Server plugin.
/// </summary>
public void Configure(IWin32Window owner)
{
_config = new Config();
ConfigManagement.LoadSettings(ref _config);
InitDeviceList();
ConfigurationDialog configDialog = new ConfigurationDialog(_deviceList);
configDialog.DeviceGuid = _config.DeviceGUID;
configDialog.AxisLimit = _config.AxisLimit;
if (configDialog.ShowDialog(owner) == DialogResult.OK)
{
if (!String.IsNullOrEmpty(configDialog.DeviceGuid))
{
_config.DeviceGUID = configDialog.DeviceGuid;
_config.AxisLimit = configDialog.AxisLimit;
ConfigManagement.SaveSettings(_config);
}
}
}
/// <summary>
/// Configure the IR Server plugin.
/// </summary>
public void Configure(IWin32Window owner)
{
Debug.WriteLine("Configure()");
_config = new Config();
ConfigManagement.LoadSettings(ref _config);
ConfigurationDialog configDialog = new ConfigurationDialog();
configDialog.DoRepeats = _config.DoRepeats;
configDialog.UseSystemRatesDelay = _config.UseSystemRatesDelay;
configDialog.FirstRepeatDelay = _config.FirstRepeatDelay;
configDialog.HeldRepeatDelay = _config.HeldRepeatDelay;
if (configDialog.ShowDialog(owner) == DialogResult.OK)
{
_config.DoRepeats = configDialog.DoRepeats;
_config.UseSystemRatesDelay = configDialog.UseSystemRatesDelay;
_config.FirstRepeatDelay = configDialog.FirstRepeatDelay;
_config.HeldRepeatDelay = configDialog.HeldRepeatDelay;
ConfigManagement.SaveSettings(_config);
}
Debug.WriteLine("Configure(): Completed");
}
public static IEnumerable <ConfigManagement.CommandsBundle> GetNftCommandsBundle()
{
return(ConfigManagement.GetCommandsBundle().Where(_ => _.Command.StartsWith("nft")));
}
