public void Cidr_GetHashCode_Returns_Same_Value_For_Equals_CIDRs()
{
var obj1 = Cidr.Parse("1.2.3.4/32");
var obj2 = Cidr.Parse("1.2.3.4/32");
Assert.AreEqual(obj1.GetHashCode(), obj2.GetHashCode());
}
public override unsafe bool IsKLined(IPAddress fullIp)
{
byte[] bytes = fullIp.GetAddressBytes();
if (bytes.Length < 4)
{
return(true);
}
unchecked
{
uint ip;
fixed(byte *pBytes = bytes)
{
int offset = bytes.Length - 4;
ip = *(uint *)&pBytes[offset];
}
Cidr[] ks = Lines.K;
for (int i = 0; i < ks.Length; i++)
{
Cidr cidr = ks[i];
uint mask = cidr.Ip >> (32 - cidr.Mask);
uint match = ip >> (32 - cidr.Mask);
if (match == mask)
{
return(true);
}
}
}
return(false);
}
public void A()
{
var a = Cidr.Parse("92.223.124.5/32");
Assert.Equal(IPAddress.Parse("92.223.124.5"), a.Start);
Assert.Equal(IPAddress.Parse("92.223.124.5"), a.End);
}
public void Cidr_Parse_Parses_Addresses_Correctly()
{
var worksheet = new ExcelWorksheetData(TestContext);
// Uncomment this block if you want to restrict the test to just those rows with a RunThis of true
// var runThis = worksheet.NBool("RunThis").GetValueOrDefault();
// if(!runThis) Assert.Fail();
var address = worksheet.EString("Parse");
Exception exception = null;
Cidr cidr = null;
try {
cidr = Cidr.Parse(address);
} catch (Exception ex) {
exception = ex;
}
Assert.AreEqual(exception != null, worksheet.NBool("Exception").GetValueOrDefault(), exception == null ? "Did not see exception" : exception.Message);
if (exception == null)
{
Assert.AreEqual(GetExcelIPAddress(worksheet, "Address"), cidr.Address);
Assert.AreEqual(GetExcelIPAddress(worksheet, "MaskedAddress"), cidr.MaskedAddress);
Assert.AreEqual(worksheet.Int("BitmaskBits"), cidr.BitmaskBits);
Assert.AreEqual(worksheet.UInt("IPv4Bitmask"), cidr.IPv4Bitmask);
Assert.AreEqual(GetExcelIPAddress(worksheet, "From"), cidr.FirstMatchingAddress);
Assert.AreEqual(GetExcelIPAddress(worksheet, "To"), cidr.LastMatchingAddress);
}
}
public static NetworkInterfaceConfiguration ExternalBridgeInterfaceConfiguration(string customIp = "")
{
var host = Host2Configuration.Host;
var ip = string.IsNullOrEmpty(customIp) ? "10.11.254.254" : customIp;
const string subnet = "16";
const NetworkRoleVerb verb = NetworkRoleVerb.eif;
var hostname = $"{host.HostName}{verb}.{host.InternalDomainPrimary}";
var alias = $"{verb}00";
var broadcast = Cidr.CalcNetwork(ip, subnet).Broadcast.ToString();
var networkInterfaceConfiguration = new NetworkInterfaceConfiguration {
Id = $"{customIp}gfEUxrgNe0qVR4HWpT1U2A",
Type = NetworkInterfaceType.External,
Hostname = hostname,
Index = 0,
Description = "default interface configuration",
RoleVerb = verb,
Alias = alias,
Mode = NetworkInterfaceMode.Static,
Ip = ip,
Subnet = subnet,
Broadcast = broadcast,
Adapter = NetworkAdapterType.Bridge,
ChildrenIf = Network2Configuration.InterfacePhysical.ToList()
};
return(networkInterfaceConfiguration);
}
public void B()
{
var a = Cidr.Parse("92.223.126.204/32");
Assert.Equal(32, a.Suffix);
Assert.Equal(IPAddress.Parse("92.223.126.204"), a.Start);
Assert.Equal(IPAddress.Parse("92.223.126.204"), a.End);
}
public void Cidr_Default_Constructor_Initialises_To_Known_State()
{
var cidr = new Cidr();
Assert.AreEqual(IPAddress.None, cidr.Address);
Assert.AreEqual(IPAddress.Parse("0.0.0.0"), cidr.MaskedAddress);
Assert.AreEqual(0, cidr.BitmaskBits);
Assert.AreEqual((uint)0, cidr.IPv4Bitmask);
}
/// <summary>
/// Fills the first and last address on the view.
/// </summary>
private void ShowCidrAddresses()
{
Cidr cidr = null;
var isEmpty = String.IsNullOrEmpty(_View.Cidr);
var isValid = !isEmpty && Cidr.TryParse(_View.Cidr, out cidr);
_View.FirstMatchingAddress = isEmpty ? "" : !isValid ? Strings.CidrInvalid : cidr.FirstMatchingAddress.ToString();
_View.LastMatchingAddress = isEmpty ? "" : !isValid ? Strings.CidrInvalid : cidr.LastMatchingAddress.ToString();
}
public int CompareTo(IPNetwork other)
{
var network = Network.CompareTo(other.Network);
if (network != 0)
{
return(network);
}
var cidr = Cidr.CompareTo(other.Cidr);
return(cidr);
}
/// <summary>
/// Called when the list view wants the columns for a CIDR address.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void listView_FetchRecordContent(object sender, ListContentEventArgs e)
{
Cidr cidr = null;
var cidrText = e.Record as string;
if (!String.IsNullOrEmpty(cidrText))
{
Cidr.TryParse(cidrText, out cidr);
}
e.ColumnTexts.Add(cidrText);
e.ColumnTexts.Add(cidr == null ? "" : cidr.FirstMatchingAddress.ToString());
e.ColumnTexts.Add(cidr == null ? "" : cidr.LastMatchingAddress.ToString());
}
public void Cidr_Equals_Returns_True_When_Properties_Match()
{
var obj1 = Cidr.Parse("1.2.3.4/32");
var obj2 = Cidr.Parse("1.2.3.4/32");
var obj3 = Cidr.Parse("5.6.7.8/32");
var obj4 = Cidr.Parse("1.2.3.4/31");
Assert.IsTrue(obj1.Equals(obj1));
Assert.IsTrue(obj1.Equals(obj2));
Assert.IsFalse(obj1.Equals(null));
Assert.IsFalse(obj1.Equals(obj3));
Assert.IsFalse(obj1.Equals(obj4));
}
public void Cidr_Matches_Compares_Addresses_Correctly()
{
var worksheet = new ExcelWorksheetData(TestContext);
// Uncomment this block if you want to restrict the test to just those rows with a RunThis of true
// var runThis = worksheet.NBool("RunThis").GetValueOrDefault();
// if(!runThis) Assert.Fail();
var cidr = Cidr.Parse(worksheet.String("CIDR"));
var address = GetExcelIPAddress(worksheet, "Address");
var expected = worksheet.Bool("Result");
var actual = cidr.Matches(address);
Assert.AreEqual(expected, actual);
}
public void Cidr_TryParse_Parses_Addresses_Correctly()
{
var worksheet = new ExcelWorksheetData(TestContext);
Cidr cidr;
var address = worksheet.EString("Parse");
var parsed = Cidr.TryParse(address, out cidr);
Assert.AreEqual(!parsed, worksheet.NBool("Exception").GetValueOrDefault());
if (parsed)
{
Assert.AreEqual(GetExcelIPAddress(worksheet, "Address"), cidr.Address);
Assert.AreEqual(GetExcelIPAddress(worksheet, "MaskedAddress"), cidr.MaskedAddress);
Assert.AreEqual(worksheet.Int("BitmaskBits"), cidr.BitmaskBits);
Assert.AreEqual(worksheet.UInt("IPv4Bitmask"), cidr.IPv4Bitmask);
}
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="access"></param>
public void Initialise(Access access)
{
if (access == null)
{
throw new ArgumentNullException("access");
}
lock (_SyncLock) {
_Initialised = true;
_DefaultAccess = access.DefaultAccess;
_Cidrs = new List <Cidr>();
foreach (var address in access.Addresses)
{
_Cidrs.Add(Cidr.Parse(address));
}
Access = access;
}
}
/// <summary>
/// Adds or inserts the CIDR address to the CIDR list.
/// </summary>
/// <param name="cidrText"></param>
/// <param name="index"></param>
private void AddOrInsertCidr(string cidrText, int index = -1)
{
Cidr cidr;
if (Cidr.TryParse(cidrText, out cidr))
{
var normalisedCidr = String.Format("{0}/{1}", cidr.MaskedAddress, cidr.BitmaskBits);
if (!Addresses.Contains(normalisedCidr))
{
if (index == -1 || index >= Addresses.Count)
{
Addresses.Add(normalisedCidr);
}
else
{
Addresses.Insert(index, normalisedCidr);
}
}
listView.SelectedRecord = normalisedCidr;
}
}
public void Load(SettingsBase settings)
{
try
{
KLine[] ks = settings.KLines.ToArray();
K = new Cidr[ks.Length];
for (int i = 0; i < K.Length; i++)
{
K[i] = ks[i].Ban;
}
}
catch (Exception ex)
{
Console.WriteLine("Unable to load K:lines: {0}", ex.Message);
}
try
{
QLine[] qs = settings.QLines.ToArray();
Q = new Regex[qs.Length];
for (int i = 0; i < Q.Length; i++)
{
try
{
Q[i] = new Regex(qs[i].Ban, RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
catch (Exception ex)
{
Console.WriteLine("The following Q:line is invalid: {0} ({1})", qs[i], ex.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Unable to load Q:lines: {0}", ex.Message);
}
}
public AntdNetwork2Module()
{
Get["/network2"] = x => {
var physicalInterfaces = Network2Configuration.InterfacePhysical.ToList();
var bridgeInterfaces = Network2Configuration.InterfaceBridge.ToList();
var bondInterfaces = Network2Configuration.InterfaceBond.ToList();
var virtualInterfaces = Network2Configuration.InterfaceVirtual.ToList();
foreach (var vif in virtualInterfaces)
{
if (physicalInterfaces.Any(_ => _ == vif) ||
bridgeInterfaces.Any(_ => _ == vif) ||
bondInterfaces.Any(_ => _ == vif))
{
virtualInterfaces.Remove(vif);
}
}
var allifs = new List <string>();
allifs.AddRange(physicalInterfaces);
allifs.AddRange(bridgeInterfaces);
allifs.AddRange(bondInterfaces);
var model = new PageNetwork2Model {
PhysicalIf = physicalInterfaces,
BridgeIf = bridgeInterfaces,
BondIf = bondInterfaces,
VirtualIf = virtualInterfaces,
AllIfs = allifs, //new List <string> { "dev1", "dev2", "dev3" },
InterfaceConfigurationList = Network2Configuration.InterfaceConfigurationList,
GatewayConfigurationList = Network2Configuration.GatewayConfigurationList,
RouteConfigurationList = Network2Configuration.RouteConfigurationList,
DnsConfigurationList = Network2Configuration.DnsConfigurationList,
Configuration = Network2Configuration.Conf.Interfaces,
NetworkHardwareConfigurationList = Network2Configuration.NetworkHardwareConfigurationList,
LagConfigurationList = Network2Configuration.NetworkAggregatedInterfaceConfigurationList,
Variables = Host2Configuration.Host,
//ActiveDnsConfiguration = Network2Configuration.Conf.ActiveDnsConfiguration
};
return(JsonConvert.SerializeObject(model));
};
Post["/network2/restart"] = x => {
new Do().NetworkChanges();
return(HttpStatusCode.OK);
};
Post["/network2/interfaceconfiguration"] = x => {
string id = Request.Form.Id;
string type = Request.Form.Type;
var typedType = type?.ToEnum <NetworkInterfaceType>() ?? NetworkInterfaceType.Null;
if (typedType == NetworkInterfaceType.Null)
{
return(HttpStatusCode.InternalServerError);
}
var index = Network2Configuration.InterfaceConfigurationList.Count(_ => _.Type == typedType);
string description = Request.Form.Description;
var typedVerb = typedType == NetworkInterfaceType.Internal ? NetworkRoleVerb.iif : NetworkRoleVerb.eif;
var alias = $"{typedVerb.ToString()}{index:D2}";
string mode = Request.Form.Mode;
var typedMode = mode?.ToEnum <NetworkInterfaceMode>() ?? NetworkInterfaceMode.Dynamic;
string ip = Request.Form.Ip;
string range = Request.Form.Range;
var vars = Host2Configuration.Host;
var hostname = "";
var subnet = "";
if (typedType == NetworkInterfaceType.Internal)
{
hostname = $"{vars.HostName}{typedVerb.ToString()}.{vars.InternalDomainPrimary}";
subnet = vars.InternalNetPrimaryBits;
}
if (typedType == NetworkInterfaceType.External)
{
hostname = $"{vars.HostName}{typedVerb.ToString()}.{vars.ExternalDomainPrimary}";
subnet = vars.ExternalNetPrimaryBits;
}
var broadcast = "";
try {
broadcast = Cidr.CalcNetwork(ip, subnet).Broadcast.ToString();
}
catch (Exception ex) {
ConsoleLogger.Error(ex.Message);
}
var model = new NetworkInterfaceConfiguration {
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
Type = typedType,
Hostname = hostname,
Index = index,
Description = description,
RoleVerb = typedVerb,
Alias = alias,
Mode = typedMode,
Ip = ip,
Range = range,
Subnet = subnet,
Broadcast = broadcast
};
Network2Configuration.AddInterfaceConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/interfaceconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveInterfaceConfiguration(guid);
return(HttpStatusCode.OK);
};
Post["/network2/gatewayconfiguration"] = x => {
string id = Request.Form.Id;
string description = Request.Form.Description;
string gatewayAddress = Request.Form.GatewayAddress;
string def = Request.Form.Default;
var model = new NetworkGatewayConfiguration {
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
Description = description,
GatewayAddress = gatewayAddress,
IsDefault = !string.IsNullOrEmpty(def) && Convert.ToBoolean(def)
};
Network2Configuration.AddGatewayConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/gatewayconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveGatewayConfiguration(guid);
return(HttpStatusCode.OK);
};
Post["/network2/lagconfiguration"] = x => {
string id = Request.Form.Id;
string parent = Request.Form.Parent;
string children = Request.Form.Children;
var model = new NetworkAggregatedInterfaceConfiguration {
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
Parent = parent,
Children = string.IsNullOrEmpty(children) ? new List <string>() : children.SplitToList()
};
Network2Configuration.AddAggregatedInterfaceConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/lagconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveAggregatedInterfaceConfiguration(guid);
return(HttpStatusCode.OK);
};
Post["/network2/routeconfiguration"] = x => {
string id = Request.Form.Id;
string destinationIp = Request.Form.DestinationIp;
string destinationRange = Request.Form.DestinationRange;
string gateway = Request.Form.Gateway;
var model = new NetworkRouteConfiguration {
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
DestinationIp = destinationIp,
DestinationRange = destinationRange,
Gateway = gateway
};
Network2Configuration.AddRouteConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/routeconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveRouteConfiguration(guid);
return(HttpStatusCode.OK);
};
Post["/network2/dnsconfiguration"] = x => {
string id = Request.Form.Id;
string type = Request.Form.Type;
var typedType = type?.ToEnum <DnsType>() ?? DnsType.Null;
if (typedType == DnsType.Null)
{
return(HttpStatusCode.InternalServerError);
}
string domain = Request.Form.Domain;
string ip = Request.Form.Ip;
var model = new DnsConfiguration {
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
Type = typedType,
Domain = domain,
Ip = ip
};
Network2Configuration.AddDnsConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/dnsconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveDnsConfiguration(guid);
return(HttpStatusCode.OK);
};
Post["/network2/dnsconfiguration/active"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.SetDnsConfigurationActive(guid);
return(HttpStatusCode.OK);
};
Post["/network2/nsupdateconfiguration"] = x => {
string id = Request.Form.Id;
string serverName = Request.Form.ServerName;
string serverPort = Request.Form.ServerPort;
string localAddress = Request.Form.LocalAddress;
string localPort = Request.Form.LocalPort;
string zoneName = Request.Form.ZoneName;
string className = Request.Form.ClassName;
string nxDomain = Request.Form.NxDomain;
string yxDomain = Request.Form.YxDomain;
string nxRrset = Request.Form.NxRrset;
string yxRrset = Request.Form.YxRrset;
string delete = Request.Form.Delete;
string add = Request.Form.Add;
var model = new NsUpdateConfiguration {
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
ServerName = serverName,
ServerPort = serverPort,
LocalAddress = localAddress,
LocalPort = localPort,
ZoneName = zoneName,
ClassName = className,
NxDomain = nxDomain,
YxDomain = yxDomain,
NxRrset = nxRrset,
YxRrset = yxRrset,
Delete = delete,
Add = add
};
Network2Configuration.AddNsUpdateConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/nsupdateconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveNsUpdateConfiguration(guid);
return(HttpStatusCode.OK);
};
Post["/network2/hardwareconfiguration"] = x => {
string id = Request.Form.Id;
string txqueuelen = Request.Form.Txqueuelen;
string mtu = Request.Form.Mtu;
string macAddress = Request.Form.MacAddress;
var model = new NetworkHardwareConfiguration()
{
Id = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
Txqueuelen = txqueuelen,
Mtu = mtu,
MacAddress = macAddress
};
Network2Configuration.AddNetworkHardwareConfiguration(model);
return(HttpStatusCode.OK);
};
Post["/network2/hardwareconfiguration/del"] = x => {
string guid = Request.Form.Guid;
Network2Configuration.RemoveNetworkHardwareConfiguration(guid);
return(HttpStatusCode.OK);
};
//Post["/network2/interface"] = x => {
// string dev = Request.Form.Device;
// string conf = Request.Form.Configuration;
// string confs = Request.Form.AdditionalConfigurations;
// string gwConf = Request.Form.GatewayConfiguration;
// string hwConf = Request.Form.HardwareConfiguration;
// string status = Request.Form.Status;
// var typedStatus = status?.ToEnum<NetworkInterfaceStatus>() ?? NetworkInterfaceStatus.Down;
// var model = new NetworkInterface {
// Device = dev,
// Configuration = conf,
// HardwareConfiguration = hwConf,
// Status = typedStatus,
// AdditionalConfigurations = confs == null ? new List<string>() : StringExtensions.SplitToList(confs),
// GatewayConfiguration = gwConf
// };
// Network2Configuration.AddInterfaceSetting(model);
// return HttpStatusCode.OK;
//};
Post["/network2/interface2"] = x => {
string conf = Request.Form.Config;
var model = JsonConvert.DeserializeObject <List <NetworkInterface> >(conf);
Network2Configuration.SaveInterfaceSetting(model);
return(HttpStatusCode.OK);
};
//Post["/network2/interface/del"] = x => {
// string dev = Request.Form.Device;
// Network2Configuration.RemoveInterfaceSetting(dev);
// return HttpStatusCode.OK;
//};
Post["/network2/add/bond"] = x => {
string name = Request.Form.Name;
try {
CommandLauncher.Launch("bond-set", new Dictionary <string, string> {
{ "$bond", name }
});
ConsoleLogger.Log($"created bond {name}");
}
catch (Exception ex) {
ConsoleLogger.Error(ex.Message);
}
return(HttpStatusCode.OK);
};
Post["/network2/add/bridge"] = x => {
string name = Request.Form.Name;
try {
CommandLauncher.Launch("brctl-add", new Dictionary <string, string> {
{ "$bridge", name }
});
ConsoleLogger.Log($"created bridge {name}");
}
catch (Exception ex) {
ConsoleLogger.Error(ex.Message);
}
return(HttpStatusCode.OK);
};
}
public override string ToString()
{
if (Null)
{
return("");
}
var s = new System.Text.StringBuilder();
if (!V6)
{
var ipl = Address;
if (IsMask)
{
int digits = 32 - Cidr;
ipl = (Int128.MaxValue << 1) | 0x1; // remove left sign bit
ipl = ipl << digits;
}
s.Append(String.Format("{0}.{1}.{2}.{3}", (ipl >> 24) & 0xFFL, (ipl >> 16) & 0xFFL, (ipl >> 8) & 0xFFL, (ipl & 0xFFL)));
}
else if (!IsMask)
{
var vals = new List <int>();
int i;
Int128 a = Address;
for (i = 0; i < 8; i++)
{
vals.Add((int)(a % c));
a = a / c;
}
int index = -1, n = 0, m = 0;
for (i = 7; i >= 0; i--)
{
if (vals[i] == 0)
{
n++;
if (n > m)
{
index = i;
m = n;
}
}
}
index += m - 1;
i = 7;
while (i >= 0)
{
if (i == index)
{
if (m == 8)
{
s.Append("::");
}
else
{
s.Append(":");
}
i -= m;
}
if (i >= 0)
{
if (i < 7)
{
s.Append(":");
}
s.Append(vals[i].ToString("x"));
}
i--;
}
}
if (IsSubnet && !(IsMask && V4))
{
s.Append('/'); s.Append(Cidr.ToString());
}
return(s.ToString());
}
public void Load(SettingsBase settings)
{
try
{
KLine[] ks = settings.KLines.ToArray();
K = new Cidr[ks.Length];
for (int i = 0; i < K.Length; i++)
{
K[i] = ks[i].Ban;
}
}
catch (Exception ex)
{
Console.WriteLine("Unable to load K:lines: {0}", ex.Message);
}
try
{
QLine[] qs = settings.QLines.ToArray();
Q = new Regex[qs.Length];
for (int i = 0; i < Q.Length; i++)
{
try
{
Q[i] = new Regex(qs[i].Ban, RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
catch (Exception ex)
{
Console.WriteLine("The following Q:line is invalid: {0} ({1})", qs[i], ex.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Unable to load Q:lines: {0}", ex.Message);
}
}
private static void Main()
{
ConsoleLogger.Log("[boot step] starting antd");
var startTime = DateTime.Now;
ConsoleLogger.Log("[boot step] core procedures");
#region [ os Rw ]
Bash.Execute("mount -o remount,rw /", false);
Bash.Execute("mount -o remount,rw /mnt/cdrom", false);
#endregion
#region [ Remove Limits ]
const string limitsFile = "/etc/security/limits.conf";
if (File.Exists(limitsFile))
{
if (!File.ReadAllText(limitsFile).Contains("root - nofile 1024000"))
{
FileWithAcl.AppendAllLines(limitsFile, new[] { "root - nofile 1024000" }, "644", "root", "wheel");
}
}
Bash.Execute("ulimit -n 1024000", false);
#endregion
#region [ Overlay Watcher ]
if (Directory.Exists(Parameter.Overlay))
{
new OverlayWatcher().StartWatching();
ConsoleLogger.Log("overlay watcher ready");
}
#endregion
#region [ Working Directories ]
Directory.CreateDirectory(Parameter.AntdCfg);
Directory.CreateDirectory(Parameter.AntdCfgServices);
Directory.CreateDirectory(Parameter.AntdCfgNetwork);
Network2Configuration.CreateWorkingDirectories();
Directory.CreateDirectory(Parameter.AntdCfgParameters);
Directory.CreateDirectory(Parameter.AntdCfgCluster);
Directory.CreateDirectory($"{Parameter.AntdCfgServices}/acls");
Directory.CreateDirectory($"{Parameter.AntdCfgServices}/acls/template");
Directory.CreateDirectory(Parameter.RepoConfig);
Directory.CreateDirectory(Parameter.RepoDirs);
Directory.CreateDirectory(Parameter.AnthillaUnits);
Directory.CreateDirectory(Parameter.TimerUnits);
Directory.CreateDirectory(Parameter.AntdCfgVfs);
Directory.CreateDirectory(Parameter.AntdCfgRssdp);
ConsoleLogger.Log("working directories created");
MountManagement.WorkingDirectories();
ConsoleLogger.Log("working directories mounted");
#endregion
#region [ Mounts ]
if (MountHelper.IsAlreadyMounted("/mnt/cdrom/Kernel/active-firmware", "/lib64/firmware") == false)
{
Bash.Execute("mount /mnt/cdrom/Kernel/active-firmware /lib64/firmware", false);
}
var kernelRelease = Bash.Execute("uname -r").Trim();
var linkedRelease = Bash.Execute("file /mnt/cdrom/Kernel/active-modules").Trim();
if (MountHelper.IsAlreadyMounted("/mnt/cdrom/Kernel/active-modules") == false &&
linkedRelease.Contains(kernelRelease))
{
var moduleDir = $"/lib64/modules/{kernelRelease}/";
DirectoryWithAcl.CreateDirectory(moduleDir);
Bash.Execute($"mount /mnt/cdrom/Kernel/active-modules {moduleDir}", false);
}
Bash.Execute("systemctl restart systemd-modules-load.service", false);
MountManagement.AllDirectories();
ConsoleLogger.Log("mounts ready");
#endregion
#region [ Check Units Location ]
var anthillaUnits = Directory.EnumerateFiles(Parameter.AnthillaUnits, "*.*", SearchOption.TopDirectoryOnly);
if (!anthillaUnits.Any())
{
var antdUnits = Directory.EnumerateFiles(Parameter.AntdUnits, "*.*", SearchOption.TopDirectoryOnly);
foreach (var unit in antdUnits)
{
var trueUnit = unit.Replace(Parameter.AntdUnits, Parameter.AnthillaUnits);
if (!File.Exists(trueUnit))
{
File.Copy(unit, trueUnit);
}
File.Delete(unit);
Bash.Execute($"ln -s {trueUnit} {unit}");
}
var appsUnits = Directory.EnumerateFiles(Parameter.AppsUnits, "*.*", SearchOption.TopDirectoryOnly);
foreach (var unit in appsUnits)
{
var trueUnit = unit.Replace(Parameter.AntdUnits, Parameter.AnthillaUnits);
if (!File.Exists(trueUnit))
{
File.Copy(unit, trueUnit);
}
File.Delete(unit);
Bash.Execute($"ln -s {trueUnit} {unit}");
}
var applicativeUnits = Directory.EnumerateFiles(Parameter.ApplicativeUnits, "*.*", SearchOption.TopDirectoryOnly);
foreach (var unit in applicativeUnits)
{
var trueUnit = unit.Replace(Parameter.AntdUnits, Parameter.AnthillaUnits);
if (!File.Exists(trueUnit))
{
File.Copy(unit, trueUnit);
}
File.Delete(unit);
Bash.Execute($"ln -s {trueUnit} {unit}");
}
}
anthillaUnits = Directory.EnumerateFiles(Parameter.AnthillaUnits, "*.*", SearchOption.TopDirectoryOnly).ToList();
if (!anthillaUnits.Any())
{
foreach (var unit in anthillaUnits)
{
Bash.Execute($"chown root:wheel {unit}");
Bash.Execute($"chmod 644 {unit}");
}
}
ConsoleLogger.Log("[check] units integrity");
#endregion
#region [ Application Keys ]
var ak = new AsymmetricKeys(Parameter.AntdCfgKeys, KeyName);
var pub = ak.PublicKey;
#endregion
#region [ Secret ]
if (!File.Exists(Parameter.AntdCfgSecret))
{
FileWithAcl.WriteAllText(Parameter.AntdCfgSecret, Secret.Gen(), "644", "root", "wheel");
}
if (string.IsNullOrEmpty(File.ReadAllText(Parameter.AntdCfgSecret)))
{
FileWithAcl.WriteAllText(Parameter.AntdCfgSecret, Secret.Gen(), "644", "root", "wheel");
}
#endregion
#region [ License Management ]
var appconfig = new AppConfiguration().Get();
ConsoleLogger.Log($"[cloud] {appconfig.CloudAddress}");
try {
var machineIds = Machine.MachineIds.Get;
ConsoleLogger.Log($"[machineid] {machineIds.PartNumber}");
ConsoleLogger.Log($"[machineid] {machineIds.SerialNumber}");
ConsoleLogger.Log($"[machineid] {machineIds.MachineUid}");
var licenseManagement = new LicenseManagement();
licenseManagement.Download("Antd", machineIds, pub);
var licenseStatus = licenseManagement.Check("Antd", machineIds, pub);
ConsoleLogger.Log(licenseStatus == null
? "[license] license results null"
: $"[license] {licenseStatus.Status} - {licenseStatus.Message}");
}
catch (Exception ex) {
ConsoleLogger.Warn(ex.Message);
}
#endregion
#region [ JournalD ]
if (JournaldConfiguration.IsActive())
{
JournaldConfiguration.Set();
}
#endregion
#region [ Import Existing Configuration ]
Network2Configuration.SetWorkingDirectories();
#region import host2model
var tmpHost = HostConfiguration.Host;
var varsFile = Host2Configuration.FilePath;
var vars = new Host2Model {
HostName = tmpHost.HostName.StoredValues.FirstOrDefault().Value,
HostChassis = tmpHost.HostChassis.StoredValues.FirstOrDefault().Value,
HostDeployment = tmpHost.HostDeployment.StoredValues.FirstOrDefault().Value,
HostLocation = tmpHost.HostLocation.StoredValues.FirstOrDefault().Value,
InternalDomainPrimary = tmpHost.InternalDomain,
ExternalDomainPrimary = tmpHost.ExternalDomain,
InternalHostIpPrimary = "",
ExternalHostIpPrimary = "",
Timezone = tmpHost.Timezone.StoredValues.FirstOrDefault().Value,
NtpdateServer = tmpHost.NtpdateServer.StoredValues.FirstOrDefault().Value,
MachineUid = Machine.MachineIds.Get.MachineUid,
Cloud = Parameter.Cloud
};
if (File.Exists(HostConfiguration.FilePath))
{
if (!File.Exists(varsFile))
{
ConsoleLogger.Log("[data import] host configuration");
Host2Configuration.Export(vars);
}
else
{
if (string.IsNullOrEmpty(File.ReadAllText(varsFile)))
{
ConsoleLogger.Log("[data import] host configuration");
Host2Configuration.Export(vars);
}
}
}
#endregion
#region import network2model
var tmpNet = NetworkConfiguration.Get();
var tmpHost2 = Host2Configuration.Host;
var niflist = new List <NetworkInterface>();
foreach (var cif in tmpNet.Interfaces)
{
ConsoleLogger.Log($"[data import] network configuration for '{cif.Interface}'");
var broadcast = "";
try {
broadcast = Cidr.CalcNetwork(cif.StaticAddress, cif.StaticRange).Broadcast.ToString();
}
catch (Exception ex) {
ConsoleLogger.Error($"[data import] {ex.Message}");
}
var hostname = $"{vars.HostName}{NetworkInterfaceType.Internal}.{vars.InternalDomainPrimary}";
var subnet = tmpHost2.InternalNetPrimaryBits;
var index = Network2Configuration.InterfaceConfigurationList.Count(_ => _.Type == NetworkInterfaceType.Internal);
var networkConfiguration = new NetworkInterfaceConfiguration {
Id = cif.Interface + cif.Guid.Substring(0, 8),
Adapter = cif.Type,
Alias = "import " + cif.Interface,
Ip = cif.StaticAddress,
Subnet = subnet,
Mode = cif.Mode,
ChildrenIf = cif.InterfaceList,
Broadcast = broadcast,
Type = NetworkInterfaceType.Internal,
Hostname = hostname,
Index = index,
Description = "import " + cif.Interface,
RoleVerb = NetworkRoleVerb.iif
};
var tryget = Network2Configuration.InterfaceConfigurationList.FirstOrDefault(_ => _.Id == networkConfiguration.Id);
if (tryget == null)
{
Network2Configuration.AddInterfaceConfiguration(networkConfiguration);
}
var ifConfig = new NetworkInterface {
Device = cif.Interface,
Configuration = networkConfiguration.Id,
AdditionalConfigurations = new List <string>(),
GatewayConfiguration = ""
};
var tryget2 = Network2Configuration.Conf.Interfaces.FirstOrDefault(_ => _.Device == cif.Interface);
if (tryget2 == null)
{
niflist.Add(ifConfig);
}
}
if (niflist.Any())
{
Network2Configuration.SaveInterfaceSetting(niflist);
}
if (!Network2Configuration.GatewayConfigurationList.Any())
{
var defaultGatewayConfiguration = new NetworkGatewayConfiguration {
Id = Random.ShortGuid(),
IsDefault = true,
GatewayAddress = vars.InternalHostIpPrimary,
Description = "DFGW"
};
Network2Configuration.AddGatewayConfiguration(defaultGatewayConfiguration);
}
#endregion
#region import parameters
if (!File.Exists($"{Parameter.AntdCfgParameters}/endcommands.conf"))
{
var tmpsetup = SetupConfiguration.Get();
HostParametersConfiguration.SetEndCommandsList(tmpsetup);
}
if (!File.Exists($"{Parameter.AntdCfgParameters}/modprobes.conf"))
{
var ddd = EnumerableExtensions.Merge(tmpHost.Modprobes.Select(_ => _.StoredValues.Select(___ => ___.Value)));
HostParametersConfiguration.SetModprobesList(ddd.ToList());
}
if (!File.Exists($"{Parameter.AntdCfgParameters}/rmmod.conf"))
{
var ddd = tmpHost.RemoveModules.StoredValues.FirstOrDefault().Value.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
HostParametersConfiguration.SetRmmodList(ddd.ToList());
}
if (!File.Exists($"{Parameter.AntdCfgParameters}/modulesblacklist.conf"))
{
var ddd = tmpHost.ModulesBlacklist;
HostParametersConfiguration.SetModulesBlacklistList(ddd.ToList());
}
if (!File.Exists($"{Parameter.AntdCfgParameters}/osparameters.conf"))
{
var list = new List <string> {
"/proc/sys/fs/file-max 1024000",
"/proc/sys/net/bridge/bridge-nf-call-arptables 0",
"/proc/sys/net/bridge/bridge-nf-call-ip6tables 0",
"/proc/sys/net/bridge/bridge-nf-call-iptables 0",
"/proc/sys/net/bridge/bridge-nf-filter-pppoe-tagged 0",
"/proc/sys/net/bridge/bridge-nf-filter-vlan-tagged 0",
"/proc/sys/net/core/netdev_max_backlog 300000",
"/proc/sys/net/core/optmem_max 40960",
"/proc/sys/net/core/rmem_max 268435456",
"/proc/sys/net/core/somaxconn 65536",
"/proc/sys/net/core/wmem_max 268435456",
"/proc/sys/net/ipv4/conf/all/accept_local 1",
"/proc/sys/net/ipv4/conf/all/accept_redirects 1",
"/proc/sys/net/ipv4/conf/all/accept_source_route 1",
"/proc/sys/net/ipv4/conf/all/rp_filter 0",
"/proc/sys/net/ipv4/conf/all/forwarding 1",
"/proc/sys/net/ipv4/conf/default/rp_filter 0",
"/proc/sys/net/ipv4/ip_forward 1",
"/proc/sys/net/ipv4/ip_local_port_range 1024 65000",
"/proc/sys/net/ipv4/ip_no_pmtu_disc 1",
"/proc/sys/net/ipv4/tcp_congestion_control htcp",
"/proc/sys/net/ipv4/tcp_fin_timeout 40",
"/proc/sys/net/ipv4/tcp_max_syn_backlog 3240000",
"/proc/sys/net/ipv4/tcp_max_tw_buckets 1440000",
"/proc/sys/net/ipv4/tcp_moderate_rcvbuf 1",
"/proc/sys/net/ipv4/tcp_mtu_probing 1",
"/proc/sys/net/ipv4/tcp_rmem 4096 87380 134217728",
"/proc/sys/net/ipv4/tcp_slow_start_after_idle 1",
"/proc/sys/net/ipv4/tcp_tw_recycle 0",
"/proc/sys/net/ipv4/tcp_tw_reuse 1",
"/proc/sys/net/ipv4/tcp_window_scaling 1",
"/proc/sys/net/ipv4/tcp_wmem 4096 65536 134217728",
"/proc/sys/net/ipv6/conf/br0/disable_ipv6 1",
"/proc/sys/net/ipv6/conf/eth0/disable_ipv6 1",
"/proc/sys/net/ipv6/conf/wlan0/disable_ipv6 1",
"/proc/sys/vm/swappiness 0"
};
HostParametersConfiguration.SetOsParametersList(list);
ConsoleLogger.Log("[data import] parameters");
}
#endregion
#endregion
#region [ Adjustments ]
new Do().ParametersChangesPre();
ConsoleLogger.Log("modules, services and os parameters ready");
#endregion
ConsoleLogger.Log("[boot step] procedures");
#region [ Users ]
var manageMaster = new ManageMaster();
manageMaster.Setup();
UserConfiguration.Import();
UserConfiguration.Set();
ConsoleLogger.Log("users config ready");
#endregion
#region [ Host Configuration & Name Service ]
new Do().HostChanges();
ConsoleLogger.Log("host configured");
ConsoleLogger.Log("name service ready");
#endregion
#region [ Network ]
new Do().NetworkChanges();
if (File.Exists("/cfg/antd/services/network.conf"))
{
File.Delete("/cfg/antd/services/network.conf");
}
if (File.Exists("/cfg/antd/services/network.conf.bck"))
{
File.Delete("/cfg/antd/services/network.conf.bck");
}
ConsoleLogger.Log("network ready");
#endregion
#region [ Firewall ]
if (FirewallConfiguration.IsActive())
{
FirewallConfiguration.Set();
}
#endregion
#region [ Dhcpd ]
DhcpdConfiguration.TryImport();
if (DhcpdConfiguration.IsActive())
{
DhcpdConfiguration.Set();
}
#endregion
#region [ Bind ]
BindConfiguration.TryImport();
BindConfiguration.DownloadRootServerHits();
if (BindConfiguration.IsActive())
{
BindConfiguration.Set();
}
#endregion
ConsoleLogger.Log("[boot step] post procedures");
#region [ Apply Setup Configuration ]
new Do().ParametersChangesPost();
ConsoleLogger.Log("machine configured (apply setup.conf)");
#endregion
#region [ Nginx ]
NginxConfiguration.TryImport();
if (NginxConfiguration.IsActive())
{
NginxConfiguration.Set();
}
#endregion
#region [ Ssh ]
if (SshdConfiguration.IsActive())
{
SshdConfiguration.Set();
}
DirectoryWithAcl.CreateDirectory(Parameter.RootSsh, "755", "root", "wheel");
DirectoryWithAcl.CreateDirectory(Parameter.RootSshMntCdrom, "755", "root", "wheel");
if (!MountHelper.IsAlreadyMounted(Parameter.RootSsh))
{
MountManagement.Dir(Parameter.RootSsh);
}
var rk = new RootKeys();
if (rk.Exists == false)
{
rk.Create();
}
var authorizedKeysConfiguration = new AuthorizedKeysConfiguration();
var storedKeys = authorizedKeysConfiguration.Get().Keys;
foreach (var storedKey in storedKeys)
{
var home = storedKey.User == "root" ? "/root/.ssh" : $"/home/{storedKey.User}/.ssh";
var authorizedKeysPath = $"{home}/authorized_keys";
if (!File.Exists(authorizedKeysPath))
{
File.Create(authorizedKeysPath);
}
FileWithAcl.AppendAllLines(authorizedKeysPath, new List <string> {
$"{storedKey.KeyValue} {storedKey.RemoteUser}"
}, "644", "root", "wheel");
Bash.Execute($"chmod 600 {authorizedKeysPath}");
Bash.Execute($"chown {storedKey.User}:{storedKey.User} {authorizedKeysPath}");
}
ConsoleLogger.Log("ssh ready");
#endregion
#region [ Service Discovery ]
try {
ServiceDiscovery.Rssdp.PublishThisDevice();
ConsoleLogger.Log("[rssdp] published device");
}
catch (Exception ex) {
ConsoleLogger.Log($"[rssdp] {ex.Message}");
}
#endregion
#region [ AntdUI ]
UiService.Setup();
ConsoleLogger.Log("antduisetup");
#endregion
ConsoleLogger.Log("[boot step] managed procedures");
#region [ Samba ]
if (SambaConfiguration.IsActive())
{
SambaConfiguration.Set();
}
#endregion
#region [ Syslog ]
if (SyslogNgConfiguration.IsActive())
{
SyslogNgConfiguration.Set();
}
#endregion
#region [ Storage - Zfs ]
foreach (var pool in Zpool.ImportList().ToList())
{
if (string.IsNullOrEmpty(pool))
{
continue;
}
ConsoleLogger.Log($"pool {pool} imported");
Zpool.Import(pool);
}
ConsoleLogger.Log("storage ready");
#endregion
#region [ Scheduler ]
Timers.MoveExistingTimers();
Timers.Setup();
Timers.Import();
Timers.Export();
foreach (var zp in Zpool.List())
{
Timers.Create(zp.Name.ToLower() + "snap", "hourly", $"/sbin/zfs snap -r {zp.Name}@${{TTDATE}}");
}
Timers.StartAll();
new SnapshotCleanup().Start(new TimeSpan(2, 00, 00));
new SyncTime().Start(new TimeSpan(0, 42, 00));
new RemoveUnusedModules().Start(new TimeSpan(2, 15, 00));
JobManager jobManager = new JobManager();
jobManager.ExecuteAllJobs();
ConsoleLogger.Log("scheduled events ready");
#endregion
#region [ Acl ]
if (AclConfiguration.IsActive())
{
AclConfiguration.Set();
AclConfiguration.ScriptSetup();
}
#endregion
#region [ C A ]
if (CaConfiguration.IsActive())
{
CaConfiguration.Set();
}
#endregion
#region [ Host Init ]
var app = new AppConfiguration().Get();
var port = app.AntdPort;
var uri = $"http://localhost:{app.AntdPort}/";
var host = new NancyHost(new Uri(uri));
host.Start();
ConsoleLogger.Log("host ready");
StaticConfiguration.DisableErrorTraces = false;
ConsoleLogger.Log($"http port: {port}");
ConsoleLogger.Log("[boot step] antd is running");
#endregion
ConsoleLogger.Log("[boot step] working procedures");
#region [ Apps ]
AppTarget.Setup();
var apps = AppsConfiguration.Get().Apps;
foreach (var mapp in apps)
{
var units = mapp.UnitLauncher;
foreach (var unit in units)
{
if (Systemctl.IsActive(unit) == false)
{
Systemctl.Restart(unit);
}
}
}
//AppTarget.StartAll();
ConsoleLogger.Log("apps ready");
#endregion
#region [ Sync / Gluster ]
if (GlusterConfiguration.IsActive())
{
GlusterConfiguration.Launch();
}
if (RsyncConfiguration.IsActive())
{
RsyncConfiguration.Set();
}
#endregion
#region [ Storage Server ]
VfsConfiguration.SetDefaults();
new Thread(() => {
try {
var srv = new StorageServer(VfsConfiguration.GetSystemConfiguration());
srv.Start();
}
catch (Exception ex) {
ConsoleLogger.Error(ex.Message);
}
}).Start();
#endregion
#region [ Tor ]
if (TorConfiguration.IsActive())
{
TorConfiguration.Start();
}
#endregion
#region [ Cluster ]
VfsWatcher = new VfsWatcher();
ClusterConfiguration.Prepare();
new Do().ClusterChanges();
ConsoleLogger.Log("[cluster] active");
#endregion
#region [ Directory Watchers ]
DirectoryWatcherCluster.Start();
DirectoryWatcherRsync.Start();
#endregion
#region [ Check Application File Acls ]
var files = Directory.EnumerateFiles(Parameter.RepoApps, "*.squashfs.xz", SearchOption.AllDirectories);
foreach (var file in files)
{
Bash.Execute($"chmod 644 {file}");
Bash.Execute($"chown root:wheel {file}");
}
ConsoleLogger.Log("[check] app-file acl");
#endregion
#region [ Check System Components ]
MachineInfo.CheckSystemComponents();
ConsoleLogger.Log("[check] system components health");
#endregion
#region [ Test ]
#if DEBUG
Test();
#endif
#endregion
ConsoleLogger.Log($"loaded in: {DateTime.Now - startTime}");
KeepAlive();
ConsoleLogger.Log("antd is closing");
host.Stop();
Console.WriteLine("host shutdown");
}
public void Cidr_Matches_Returns_False_If_Passed_Null()
{
var cidr = new Cidr();
Assert.AreEqual(false, cidr.Matches(null));
}
public void Cidr_Matches_Returns_False_If_Passed_An_IPv6()
{
var cidr = new Cidr();
Assert.AreEqual(false, cidr.Matches(IPAddress.Parse("2001:0DB8:AC10:FE01::")));
}
