private static DNSServer GetDNSServer(int serviceId)
{
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, serviceId);
return(dns);
}
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group)
{
List <string> items = new List <string>();
// get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return(items);
}
// Mail provider
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, serviceId);
// IDN: The list of importable names is populated with unicode names, to make it easier for the user
var idn = new IdnMapping();
if (itemType == typeof(DnsZone))
{
items.AddRange(dns.GetZones());
}
return(items);
}
public static void CreateDnsServer(string ipAddressOfServer)
{
var domainToIp = GetDataFromJson(NameCollectEntryDomainToIp);
var ipToDomain = GetDataFromJson(NameCollectEntryIpToDomain);
_server = new DNSServer(IPAddress.Parse(ipAddressOfServer), 53, ipToDomain, domainToIp);
}
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
{
if (!(item is DnsZone))
{
return(0);
}
// DNS provider
DNSServer dns = GetDNSServer(item.ServiceId);
// zone records serialized
XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord));
try
{
// get zone records
DnsRecord[] records = dns.GetZoneRecords(item.Name);
// serialize zone records
foreach (DnsRecord record in records)
{
serializer.Serialize(writer, record);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Could not read zone records");
}
return(0);
}
static void Test4()
{
//ApiTest.Main();
//TestService.ServiceMain();
//HeaderLengthPacket.Test();
var svr = new DNSServer();
svr.Start();
}
public int RestoreItem(string tempFolder, XmlNode itemNode, int itemId, Type itemType,
string itemName, int packageId, int serviceId, ResourceGroupInfo group)
{
if (itemType != typeof(DnsZone))
{
return(0);
}
// DNS provider
DNSServer dns = GetDNSServer(serviceId);
// check service item
if (!dns.ZoneExists(itemName))
{
// create primary and secondary zones
AddZone(packageId, serviceId, itemName, false, false);
// restore records
XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord));
List <DnsRecord> records = new List <DnsRecord>();
foreach (XmlNode childNode in itemNode.ChildNodes)
{
if (childNode.Name == "DnsRecord")
{
records.Add((DnsRecord)serializer.Deserialize(new XmlNodeReader(childNode)));
}
}
dns.AddZoneRecords(itemName, records.ToArray());
}
// check if meta-item exists
int zoneId = 0;
DnsZone item = (DnsZone)PackageController.GetPackageItemByName(packageId, itemName, typeof(DnsZone));
if (item == null)
{
// restore meta-item
item = new DnsZone();
item.Name = itemName;
item.PackageId = packageId;
item.ServiceId = serviceId;
zoneId = PackageController.AddPackageItem(item);
}
else
{
zoneId = item.Id;
}
// restore domains
RestoreDomainByZone(itemName, packageId, zoneId);
return(0);
}
private static void DeleteEntry(DNSServer s, string command)
{
string[] commandList = command.Split(' ');
if (commandList.Length != 2)
{
return;
}
string domain = commandList[1];
//add the new entry
BConsole.WriteLine(s.Processor.DeleteDNSEntry(domain), ConsoleColor.Yellow);
}
static void Main(string[] args)
{
DNSServer s = new DNSServer();
s.VerboseLog += VerboseLog;
s.ErrorLog += ErrorLog;
s.Start();
for (string command; (command = CommandlineHelper.ParseCommand()) != CommandlineHelper.COMMAND_EXIT;)
{
CommandlineHelper.Execute(s, command);
}
s.Stop();
}
private static void AddNewEntry(DNSServer s, string command)
{
string[] commandList = command.Split(' ');
if (commandList.Length != 3)
{
return;
}
string domain = commandList[1];
string ip = commandList[2];
//add the new entry
BConsole.WriteLine(s.Processor.AddDNSEntry(domain, ip), ConsoleColor.Yellow);
}
protected override void StartWork(String reason)
{
// 修改数据库默认目录
var xcode = XCode.Setting.Current;
if (xcode.IsNew)
{
xcode.ShowSQL = false;
xcode.SQLiteDbPath = "..\\Data";
xcode.Save();
}
// 初始化数据库
Task.Run(() =>
{
var n = 0;
n = Rule.Meta.Count;
n = Record.Meta.Count;
n = Visitor.Meta.Count;
});
var set = Setting.Current;
// 启动服务器
var svr = new DNSServer();
if (set.Debug)
{
svr.Log = XTrace.Log;
}
//svr.Parent = set.DNSServer + "," + svr.Parent;
svr.Parents.AddRange(svr.GetLocalDNS());
svr.SetParents(set.DNSServer);
svr.OnRequest += Server_OnRequest;
svr.OnResponse += Server_OnResponse;
svr.OnNew += Server_OnNew;
svr.Start();
Server = svr;
base.StartWork(reason);
}
public static void Execute(DNSServer s, string command)
{
if (command == null)
{
return;
}
switch (command.Split(' ')[0].ToLower())
{
case COMMAND_HELP:
string helpText = @"Retrieving help information
There are 4 commands:
- Exit
- DNSShow Gets a list of records usage: dnsshow -[domain|ip] [searchtext]
- DNSNew Creates a new DNS entry usage: dnsnew [domain] [ip]
- DNSEdit Edits the DNS entry, the flag decides what to search for. usage: dnsedit -[domain|ip] [current domain] [new ip/domain]
- DNSRemove Removes the DNS entry, AND all of it's Sub Domains. usage: dnsremove [domain]
Commands that have a - in the usage clause interpret these as flags.";
BConsole.WriteLine(helpText, ConsoleColor.Yellow);
break;
case COMMAND_NEW_ENTRY:
AddNewEntry(s, command);
break;
case COMMAND_EDIT_ENTRY:
EditEntry(s, command);
break;
case COMMAND_DELETE_ENTRY:
DeleteEntry(s, command);
break;
case COMMAND_SHOW_ENTRY:
ShowEntry(s, command);
break;
}
}
private static void ShowEntry(DNSServer s, string command)
{
string[] commandList = command.Split(' ');
if (commandList.Length != 3)
{
return;
}
string flag = commandList[1];
string value = commandList[2];
switch (flag)
{
case "-domain":
BConsole.WriteLine(s.Processor.ShowDNSEntry(true, value), ConsoleColor.Yellow);
break;
case "-ip":
BConsole.WriteLine(s.Processor.ShowDNSEntry(false, value), ConsoleColor.Yellow);
break;
}
}
private static void EditEntry(DNSServer s, string command)
{
string[] commandList = command.Split(' ');
if (commandList.Length != 4)
{
return;
}
string flag = commandList[1];
string currentDomain = commandList[2];
string newValue = commandList[3];
switch (flag)
{
case "-domain":
BConsole.WriteLine(s.Processor.EditDNSEntry(true, currentDomain, newValue), ConsoleColor.Yellow);
break;
case "-ip":
BConsole.WriteLine(s.Processor.EditDNSEntry(false, currentDomain, newValue), ConsoleColor.Yellow);
break;
}
}
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group)
{
List <string> items = new List <string>();
// get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return(items);
}
// Mail provider
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, serviceId);
if (itemType == typeof(DnsZone))
{
items.AddRange(dns.GetZones());
}
return(items);
}
public static DnsRecord[] GetDnsZoneRecords(int domainId)
{
// load domain info
DomainInfo domain = GetDomain(domainId);
// get DNS zone
DnsZone zoneItem = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
if (zoneItem != null)
{
// fill records array
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, zoneItem.ServiceId);
return dns.GetZoneRecords(domain.DomainName);
}
return new DnsRecord[] { };
}
public static int AddDnsZoneRecord(int domainId, string recordName, DnsRecordType recordType,
string recordData, int mxPriority, int srvPriority, int srvWeight, int srvPort)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
// load domain info
DomainInfo domain = GetDomain(domainId);
// check package
int packageCheck = SecurityContext.CheckPackage(domain.PackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
// get DNS service
DnsZone zoneItem = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
if (zoneItem == null)
return 0;
// place log record
TaskManager.StartTask("DNS_ZONE", "ADD_RECORD", domain.DomainName, domain.ZoneItemId);
try
{
// check if record already exists
if (GetDnsZoneRecord(domainId, recordName, recordType, recordData) != null)
return 0;
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, zoneItem.ServiceId);
DnsRecord record = new DnsRecord();
record.RecordType = recordType;
record.RecordName = recordName;
record.RecordData = recordData;
record.MxPriority = mxPriority;
record.SrvPriority = srvPriority;
record.SrvWeight = srvWeight;
record.SrvPort = srvPort;
dns.AddZoneRecord(zoneItem.Name, record);
return 0;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int DeleteZone(int zoneItemId)
{
// delete DNS zone if applicable
DnsZone zoneItem = (DnsZone)PackageController.GetPackageItem(zoneItemId);
//
if (zoneItem != null)
{
TaskManager.StartTask("DNS_ZONE", "DELETE", zoneItem.Name, zoneItemId);
//
try
{
// delete DNS zone
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, zoneItem.ServiceId);
// delete secondary zones
StringDictionary primSettings = ServerController.GetServiceSettings(zoneItem.ServiceId);
string strSecondaryServices = primSettings["SecondaryDNSServices"];
if (!String.IsNullOrEmpty(strSecondaryServices))
{
string[] secondaryServices = strSecondaryServices.Split(',');
foreach (string strSecondaryId in secondaryServices)
{
try
{
int secondaryId = Utils.ParseInt(strSecondaryId, 0);
if (secondaryId == 0)
{
continue;
}
DNSServer secDns = new DNSServer();
ServiceProviderProxy.Init(secDns, secondaryId);
secDns.DeleteZone(zoneItem.Name);
}
catch (Exception ex1)
{
// problem when deleting secondary zone
TaskManager.WriteError(ex1, "Error deleting secondary DNS zone");
}
}
}
try
{
dns.DeleteZone(zoneItem.Name);
}
catch (Exception ex2)
{
TaskManager.WriteError(ex2, "Error deleting primary DNS zone");
}
// delete service item
PackageController.DeletePackageItem(zoneItemId);
// Delete also all seconday service items
var zoneItems = PackageController.GetPackageItemsByType(zoneItem.PackageId, ResourceGroups.Dns, typeof(SecondaryDnsZone));
foreach (var item in zoneItems.Where(z => z.Name == zoneItem.Name))
{
PackageController.DeletePackageItem(item.Id);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
//
return(0);
}
public static void AddServiceDNSRecords(int packageId, string groupName, DomainInfo domain, string serviceIP, bool wildcardOnly)
{
int serviceId = PackageController.GetPackageServiceId(packageId, groupName);
if (serviceId > 0)
{
List<DnsRecord> tmpZoneRecords = new List<DnsRecord>();
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(serviceId);
if (wildcardOnly)
{
List<GlobalDnsRecord> temp = new List<GlobalDnsRecord>();
foreach (GlobalDnsRecord d in dnsRecords)
{
if ((d.RecordName == "*") ||
(d.RecordName == "@"))
temp.Add(d);
}
dnsRecords = temp;
}
DnsZone zone = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
tmpZoneRecords.AddRange(DnsServerController.BuildDnsResourceRecords(dnsRecords, "", domain.ZoneName, serviceIP));
try
{
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, zone.ServiceId);
DnsRecord[] domainRecords = dns.GetZoneRecords(domain.DomainName);
List<DnsRecord> zoneRecords = new List<DnsRecord>();
foreach (DnsRecord t in tmpZoneRecords)
{
if (!RecordDoesExist(t, domainRecords))
zoneRecords.Add(t);
}
// add new resource records
dns.AddZoneRecords(zone.Name, zoneRecords.ToArray());
}
catch (Exception ex1)
{
TaskManager.WriteError(ex1, "Error updating DNS records");
}
}
}
/// <summary>
/// Adds SharePoint site collection.
/// </summary>
/// <param name="item">Site collection description.</param>
/// <returns>Created site collection id within metabase.</returns>
public static int AddSiteCollection(SharePointEnterpriseSiteCollection item)
{
// Check account.
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// Check package.
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// Check quota.
OrganizationStatistics orgStats = OrganizationController.GetOrganizationStatistics(item.OrganizationId);
//QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_SITES);
if (orgStats.AllocatedSharePointEnterpriseSiteCollections > -1 &&
orgStats.CreatedSharePointEnterpriseSiteCollections >= orgStats.AllocatedSharePointEnterpriseSiteCollections)
{
return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT);
}
// Check if stats resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharepointEnterpriseServer);
if (serviceId == 0)
{
return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE);
}
StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId);
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_ENTERPRISE_USESHAREDSSL);
Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]);
Organization org = OrganizationController.GetOrganization(item.OrganizationId);
string siteName = item.Name;
if (quota.QuotaAllocatedValue == 1)
{
string sslRoot = hostedSharePointSettings["SharedSSLRoot"];
string defaultDomain = org.DefaultDomain;
string hostNameBase = string.Empty;
string[] tmp = defaultDomain.Split('.');
if (tmp.Length == 2)
{
hostNameBase = tmp[0];
}
else
{
if (tmp.Length > 2)
{
hostNameBase = tmp[0] + tmp[1];
}
}
int counter = 0;
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot);
siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot);
while (DataProvider.CheckServiceItemExists(serviceId, item.Name, "WebsitePanel.Providers.SharePoint.SharePointEnterpriseSiteCollection, WebsitePanel.Providers.Base"))
{
counter++;
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot);
siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot);
}
}
else
{
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, item.Name);
}
if (rootWebApplicationUri.Port > 0 && rootWebApplicationUri.Port != 80 && rootWebApplicationUri.Port != 443)
{
item.PhysicalAddress = String.Format("{0}:{1}", item.Name, rootWebApplicationUri.Port);
}
else
{
item.PhysicalAddress = item.Name;
}
if (Utils.ParseBool(hostedSharePointSettings["LocalHostFile"], false))
{
item.RootWebApplicationInteralIpAddress = hostedSharePointSettings["RootWebApplicationInteralIpAddress"];
item.RootWebApplicationFQDN = item.Name.Replace(rootWebApplicationUri.Scheme + "://", "");
}
item.MaxSiteStorage = RecalculateMaxSize(org.MaxSharePointEnterpriseStorage, (int)item.MaxSiteStorage);
item.WarningStorage = item.MaxSiteStorage == -1 ? -1 : Math.Min((int)item.WarningStorage, item.MaxSiteStorage);
// Check package item with given name already exists.
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointEnterpriseSiteCollection)) != null)
{
return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS);
}
// Log operation.
TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "ADD_SITE_COLLECTION", item.Name);
try
{
// Create site collection on server.
HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId);
hostedSharePointServer.Enterprise_CreateSiteCollection(item);
// Make record in metabase.
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
hostedSharePointServer.Enterprise_SetPeoplePickerOu(item.Name, org.DistinguishedName);
int dnsServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Dns);
if (dnsServiceId > 0)
{
string[] tmpStr = siteName.Split('.');
string hostName = tmpStr[0];
string domainName = siteName.Substring(hostName.Length + 1, siteName.Length - (hostName.Length + 1));
List <GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(serviceId);
List <DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(dnsRecords, hostName, domainName, "");
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, dnsServiceId);
// add new resource records
dns.AddZoneRecords(domainName, resourceRecords.ToArray());
}
TaskManager.ItemId = itemId;
return(itemId);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public async Task <DNSInfo> Query(String DomainName,
params UInt16[] ResourceRecordTypes)
{
if (ResourceRecordTypes.Length == 0)
{
ResourceRecordTypes = new UInt16[1] {
255
}
}
;
#region Try to get an answer from the DNS cache
var DNSInfo = _DNSCache.GetDNSInfo(DomainName);
if (DNSInfo != null)
{
//var tcs = new TaskCompletionSource<DNSInfo>();
//tcs.SetResult(DNSInfo);
//return tcs.Task;
return(DNSInfo);
}
#endregion
#region Query all DNS server(s) in parallel...
// Preparing the DNS query packet
var QueryPacket = new DNSQuery(DomainName, RecursionDesired, ResourceRecordTypes);
var AllDNSServerRequests = DNSServers.Select(DNSServer => {
return(Task <DNSInfo> .Factory.StartNew(() => {
var data = new Byte[512];
Int32 length;
Socket socket = null;
try
{
var serverAddress = IPAddress.Parse(DNSServer.IPAddress.ToString());
var endPoint = (EndPoint) new IPEndPoint(serverAddress, DNSServer.Port.ToInt32());
socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, (Int32)QueryTimeout.TotalMilliseconds);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, (Int32)QueryTimeout.TotalMilliseconds);
socket.Connect(endPoint);
socket.SendTo(QueryPacket.Serialize(), endPoint);
length = socket.ReceiveFrom(data, ref endPoint);
}
catch (Exception e)
{
// A SocketException might be thrown after the timeout was reached!
throw new Exception("DNS server '" + DNSServer.ToString() + "' did not respond within " + QueryTimeout.TotalSeconds + " seconds!");
}
finally
{
if (socket != null)
{
socket.Shutdown(SocketShutdown.Both);
}
}
return ReadResponse(DNSServer, QueryPacket.TransactionId, new MemoryStream(data));
},
TaskCreationOptions.AttachedToParent));
}).ToArray();
#endregion
#region Cache all replies...
AllDNSServerRequests.
ForEach(DNSServerTask => DNSServerTask.ContinueWith(x => {
try
{
if (x.Result != null)
{
AddToCache(DomainName, x.Result);
}
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
Debug.WriteLine("[" + DateTime.Now + "] DNS exception " + e.Message);
}
}));
#endregion
// Return first/fastest reply
var FirstReply = Task.WhenAny(AllDNSServerRequests);
return(FirstReply.Result.Result);
}
public static int AddZone(int packageId, int serviceId, string zoneName, bool addPackageItem, bool ignoreGlobalDNSRecords)
{
// get DNS provider
DNSServer dns = GetDNSServer(serviceId);
// Ensure zoneName is in ascii before saving to database
zoneName = GetAsciiZoneName(zoneName);
// check if zone already exists
if (dns.ZoneExists(zoneName))
{
return(BusinessErrorCodes.ERROR_DNS_ZONE_EXISTS);
}
//
TaskManager.StartTask("DNS_ZONE", "ADD", zoneName);
//
int zoneItemId = default(int);
//
try
{
// get secondary DNS services
StringDictionary primSettings = ServerController.GetServiceSettings(serviceId);
string[] primaryIPAddresses = GetExternalIPAddressesFromString(primSettings["ListeningIPAddresses"]);
List <string> secondaryIPAddresses = new List <string>();
List <int> secondaryServiceIds = new List <int>();
string strSecondaryServices = primSettings["SecondaryDNSServices"];
if (!String.IsNullOrEmpty(strSecondaryServices))
{
string[] secondaryServices = strSecondaryServices.Split(',');
foreach (string strSecondaryId in secondaryServices)
{
int secondaryId = Utils.ParseInt(strSecondaryId, 0);
if (secondaryId == 0)
{
continue;
}
secondaryServiceIds.Add(secondaryId);
StringDictionary secondarySettings = ServerController.GetServiceSettings(secondaryId);
// add secondary IPs to the master array
secondaryIPAddresses.AddRange(
GetExternalIPAddressesFromString(secondarySettings["ListeningIPAddresses"]));
}
}
// add "Allow zone transfers"
string allowTransfers = primSettings["AllowZoneTransfers"];
if (!String.IsNullOrEmpty(allowTransfers))
{
string[] ips = Utils.ParseDelimitedString(allowTransfers, '\n', ' ', ',', ';');
foreach (string ip in ips)
{
if (!secondaryIPAddresses.Contains(ip))
{
secondaryIPAddresses.Add(ip);
}
}
}
// add primary zone
dns.AddPrimaryZone(zoneName, secondaryIPAddresses.ToArray());
// get DNS zone records
List <GlobalDnsRecord> records = ServerController.GetDnsRecordsTotal(packageId);
// get name servers
PackageSettings packageSettings = PackageController.GetPackageSettings(packageId, PackageSettings.NAME_SERVERS);
string[] nameServers = new string[] { };
if (!String.IsNullOrEmpty(packageSettings["NameServers"]))
{
nameServers = packageSettings["NameServers"].Split(';');
}
// build records list
List <DnsRecord> zoneRecords = new List <DnsRecord>();
string primaryNameServer = "ns." + zoneName;
if (nameServers.Length > 0)
{
primaryNameServer = nameServers[0];
}
// update SOA record
string hostmaster = primSettings["ResponsiblePerson"];
if (String.IsNullOrEmpty(hostmaster))
{
hostmaster = "hostmaster." + zoneName;
}
else
{
hostmaster = Utils.ReplaceStringVariable(hostmaster, "domain_name", zoneName);
}
dns.UpdateSoaRecord(zoneName, "", primaryNameServer, hostmaster);
// add name servers
foreach (string nameServer in nameServers)
{
DnsRecord ns = new DnsRecord();
ns.RecordType = DnsRecordType.NS;
ns.RecordName = "";
ns.RecordData = nameServer;
zoneRecords.Add(ns);
}
if (!ignoreGlobalDNSRecords)
{
// add all other records
zoneRecords.AddRange(BuildDnsResourceRecords(records, "", zoneName, ""));
}
// add zone records
dns.AddZoneRecords(zoneName, zoneRecords.ToArray());
// add secondary zones
foreach (int secondaryId in secondaryServiceIds)
{
try
{
// add secondary zone
DNSServer secDns = GetDNSServer(secondaryId);
secDns.AddSecondaryZone(zoneName, primaryIPAddresses);
RegisterZoneItems(packageId, secondaryId, zoneName, false);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Error adding secondary zone (service ID = " + secondaryId + ")");
}
}
if (!addPackageItem)
{
return(0);
}
// add service item
zoneItemId = RegisterZoneItems(packageId, serviceId, zoneName, true);
//
TaskManager.ItemId = zoneItemId;
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
//
return(zoneItemId);
}
public static int DeleteDnsZoneRecord(int domainId, string recordName, DnsRecordType recordType,
string recordData)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
// load domain info
DomainInfo domain = GetDomain(domainId);
// check package
int packageCheck = SecurityContext.CheckPackage(domain.PackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
// get DNS service
DnsZone zoneItem = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
if (zoneItem == null)
return 0;
try
{
// place log record
TaskManager.StartTask("DNS_ZONE", "DELETE_RECORD", domain.DomainName);
TaskManager.ItemId = domain.ZoneItemId;
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, zoneItem.ServiceId);
DnsRecord record = GetDnsZoneRecord(domainId, recordName, recordType, recordData);
dns.DeleteZoneRecord(zoneItem.Name, record);
return 0;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
/// <summary>
/// Deletes SharePoint site collection with given id.
/// </summary>
/// <param name="itemId">Site collection id within metabase.</param>
/// <returns>?</returns>
public static int DeleteSiteCollection(int itemId)
{
// Check account.
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// Load original meta item
SharePointEnterpriseSiteCollection origItem = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND);
}
// Get service settings.
StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(origItem.ServiceId);
Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]);
string siteName = origItem.Name.Replace(String.Format("{0}://", rootWebApplicationUri.Scheme), String.Empty);
// Log operation.
TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "DELETE_SITE", origItem.Name, itemId);
try
{
// Delete site collection on server.
HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId);
hostedSharePointServer.Enterprise_DeleteSiteCollection(origItem);
// Delete record in metabase.
PackageController.DeletePackageItem(origItem.Id);
int dnsServiceId = PackageController.GetPackageServiceId(origItem.PackageId, ResourceGroups.Dns);
if (dnsServiceId > 0)
{
string[] tmpStr = siteName.Split('.');
string hostName = tmpStr[0];
string domainName = siteName.Substring(hostName.Length + 1, siteName.Length - (hostName.Length + 1));
List <GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(origItem.ServiceId);
List <DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(dnsRecords, hostName, domainName, "");
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, dnsServiceId);
// add new resource records
dns.DeleteZoneRecords(domainName, resourceRecords.ToArray());
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static void SetDnsServer(DNSServer server)
{
_server = server;
}
