private static DnsProxySettings CreateDnsProxySettings()
{
List <ListenerSettings> listeners = new List <ListenerSettings>();
foreach (AGDnsApi.ag_listener_protocol protocol in
(AGDnsApi.ag_listener_protocol[])Enum.GetValues(typeof(AGDnsApi.ag_listener_protocol)))
{
foreach (IPAddress listenerAddress in new [] { IPAddress.Loopback, IPAddress.IPv6Loopback })
{
ListenerSettings listener = new ListenerSettings
{
EndPoint = new IPEndPoint(listenerAddress, DNS_PROXY_PORT),
Protocol = protocol,
IsPersistent = true,
IdleTimeoutMs = 3000
};
listeners.Add(listener);
}
}
DnsProxySettings dnsProxySettings = new DnsProxySettings
{
Upstreams = new List <UpstreamOptions>
{
CreateUpstreamOptions()
},
Fallbacks = new List <UpstreamOptions>(),
Dns64 = new Dns64Settings
{
Upstreams = new List <UpstreamOptions>(),
MaxTries = 5,
WaitTimeMs = 2000
},
BlockedResponseTtlSec = 0,
BlockingMode = AGDnsApi.ag_dnsproxy_blocking_mode.DEFAULT,
BlockIpv6 = true,
CustomBlockingIpv4 = null,
CustomBlockingIpv6 = null,
DnsCacheSize = 128,
EngineParams = new EngineParams
{
FilterParams = new List <FilterParams>
{
new FilterParams
{
Id = 0,
Data = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
SDNS_FILTER_RELATIVE_PATH),
InMemory = false
}
}
},
Listeners = listeners,
Ipv6Available = false
};
return(dnsProxySettings);
}
/// <summary>
/// Starts DNS filtering
/// </summary>
/// <param name="dnsApiConfiguration">Dns proxy configuration
/// (<seealso cref="DnsApiConfiguration"/>)</param>
/// <exception cref="NotSupportedException">Thrown
/// if current API version is not supported</exception>
/// <exception cref="ArgumentNullException">Thrown,
/// if <see cref="dnsApiConfiguration"/> is not specified</exception>
/// <exception cref="InvalidOperationException">Thrown, if cannot starting the proxy server
/// for any reason</exception>
public void StartDnsFiltering(DnsApiConfiguration dnsApiConfiguration)
{
lock (SYNC_ROOT)
{
try
{
if (dnsApiConfiguration == null)
{
throw new ArgumentNullException(
"dnsApiConfiguration",
"dnsApiConfiguration is not specified");
}
if (!dnsApiConfiguration.IsEnabled)
{
LOG.InfoFormat("DNS filtering is disabled, doing nothing");
return;
}
LOG.InfoFormat("Starting the DNS filtering");
m_DnsProxyServer = new Dns.DnsProxyServer.DnsProxyServer(
dnsApiConfiguration.DnsProxySettings,
dnsApiConfiguration.DnsProxyServerCallbackConfiguration);
m_CurrentDnsProxySettings = dnsApiConfiguration.DnsProxySettings;
m_DnsProxyServer.Start();
LOG.InfoFormat("Starting the DNS filtering has been successfully completed");
}
catch (Exception ex)
{
LOG.ErrorFormat("Starting the DNS filtering failed with an error", ex);
throw;
}
}
}
internal static DnsProxySettings FromNativeObject(
AGDnsApi.ag_dnsproxy_settings dnsProxySettingsC)
{
List <UpstreamOptions> upstreams = MarshalUtils.AgListToList <AGDnsApi.ag_upstream_options, UpstreamOptions>(
dnsProxySettingsC.upstreams,
FromNativeObject);
List <UpstreamOptions> fallbacks = MarshalUtils.AgListToList <AGDnsApi.ag_upstream_options, UpstreamOptions>(
dnsProxySettingsC.fallbacks,
FromNativeObject);
Dns64Settings dns64 = FromNativeObject(dnsProxySettingsC.pDns64);
EngineParams engineParams = FromNativeObject(dnsProxySettingsC.FilterParams);
List <ListenerSettings> listeners =
MarshalUtils.AgListToList <AGDnsApi.ag_listener_settings, ListenerSettings>(
dnsProxySettingsC.listeners,
FromNativeObject);
DnsProxySettings dnsProxySettings = new DnsProxySettings
{
Upstreams = upstreams,
Fallbacks = fallbacks,
Dns64 = dns64,
EngineParams = engineParams,
Listeners = listeners,
};
MarshalUtils.CopyFieldsToProperties(dnsProxySettingsC, dnsProxySettings);
MarshalUtils.AllPtrsToStrings(dnsProxySettingsC, dnsProxySettings);
return(dnsProxySettings);
}
/// <summary>
/// Converts the managed <see cref="dnsProxySettings"/>
/// (<seealso cref="DnsProxySettings"/>) to the native <see cref="AGDnsApi.ag_dnsproxy_settings"/> object
/// </summary>
/// <param name="dnsProxySettings"><see cref="DnsProxySettings"/> instance to convert</param>
/// <param name="allocatedPointers">List of pointers, which were allocated.
/// Pointers, which will be referred to a newly allocated memory
/// (within the process of marshaling the string to the pointer)
/// will be added to this list.
/// If this list is not specified (null),
/// a new created pointer will not be added anywhere</param>
/// The resulting pointer (<seealso cref="IntPtr"/>) must be freed
/// with <see cref="MarshalUtils.SafeFreeHGlobal(IntPtr)"/>>
/// <returns>An instance of <see cref="AGDnsApi.ag_dnsproxy_settings"/></returns>
internal static AGDnsApi.ag_dnsproxy_settings ToNativeObject(
DnsProxySettings dnsProxySettings,
Queue <IntPtr> allocatedPointers)
{
MarshalUtils.ag_list upstreamsC = MarshalUtils.ListToAgList(
dnsProxySettings.Upstreams,
ToNativeObject,
allocatedPointers);
MarshalUtils.ag_list fallbacksC = MarshalUtils.ListToAgList(
dnsProxySettings.Fallbacks,
ToNativeObject,
allocatedPointers);
MarshalUtils.ag_list fallbackDomains = MarshalUtils.ListToAgList(
dnsProxySettings.FallbackDomains,
MarshalUtils.StringToPtr,
allocatedPointers);
IntPtr pDns64C = IntPtr.Zero;
if (dnsProxySettings.Dns64 != null)
{
AGDnsApi.ag_dns64_settings dns64C =
ToNativeObject(dnsProxySettings.Dns64, allocatedPointers);
pDns64C = MarshalUtils.StructureToPtr(dns64C, allocatedPointers);
}
AGDnsApi.ag_filter_engine_params filterEngineParamsC =
ToNativeObject(dnsProxySettings.EngineParams, allocatedPointers);
MarshalUtils.ag_list listenersC = MarshalUtils.ListToAgList(
dnsProxySettings.Listeners,
ToNativeObject,
allocatedPointers);
IntPtr pOutboundProxySessionC = IntPtr.Zero;
if (dnsProxySettings.OutboundProxySettings != null)
{
AGDnsApi.ag_outbound_proxy_settings outboundProxySettingsC =
ToNativeObject(dnsProxySettings.OutboundProxySettings, allocatedPointers);
pOutboundProxySessionC = MarshalUtils.StructureToPtr(outboundProxySettingsC, allocatedPointers);
}
AGDnsApi.ag_dnsproxy_settings dnsProxySettingsC = new AGDnsApi.ag_dnsproxy_settings
{
upstreams = upstreamsC,
fallbacks = fallbacksC,
pDns64 = pDns64C,
FilterParams = filterEngineParamsC,
listeners = listenersC,
outbound_proxy = pOutboundProxySessionC,
fallbackDomains = fallbackDomains,
};
MarshalUtils.CopyPropertiesToFields(dnsProxySettings, ref dnsProxySettingsC);
MarshalUtils.AllStringsToPtrs(dnsProxySettings, ref dnsProxySettingsC, allocatedPointers);
return(dnsProxySettingsC);
}
/// <summary>
/// Gets the default DNS proxy settings as a <see cref="DnsProxySettings"/> object
/// </summary>
/// <returns>Current DNS proxy settings
/// (<seealso cref="DnsProxySettings"/>)</returns>
/// <exception cref="InvalidOperationException">Thrown,
/// if cannot get the default dns proxy settings via native method</exception>
public static DnsProxySettings GetDefaultDnsProxySettings()
{
LOG.Info("Get default DnsProxyServer settings");
DnsProxySettings defaultDnsProxySettings =
GetDnsProxySettings(AGDnsApi.ag_dnsproxy_settings_get_default);
return(defaultDnsProxySettings);
}
/// <summary>
/// Gets the default DNS proxy settings as a <see cref="DnsProxySettings"/> object
/// </summary>
/// <returns>Current DNS proxy settings
/// (<seealso cref="DnsProxySettings"/>)</returns>
/// <exception cref="InvalidOperationException">Thrown,
/// if cannot get the default dns proxy settings via native method</exception>
public static DnsProxySettings GetDefaultDnsProxySettings()
{
Logger.Info("Get default DnsProxyServer settings");
IntPtr pSettings = AGDnsApi.ag_dnsproxy_settings_get_default();
DnsProxySettings defaultDnsProxySettings =
GetDnsProxySettings(pSettings);
return(defaultDnsProxySettings);
}
public static void Main(string[] args)
{
string redirectorAppExecutablePath = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
REDIRECTOR_EXECUTABLE_RELATIVE_PATH);
bool isRedirectorExist = File.Exists(redirectorAppExecutablePath);
try
{
m_LogProvider = new ColoredConsoleLogProvider();
LogProvider.SetCurrentLogProvider(m_LogProvider);
#if LOG_TO_FILE
ConsoleToFileRedirector.Start("Logs");
#endif
m_DnsApi = DnsApi.Instance;
m_DnsApi.InitLogger(LogLevel.Debug);
DnsProxySettings dnsProxySettings = CreateDnsProxySettings();
IDnsProxyServerCallbackConfiguration dnsProxyServerCallbackConfiguration =
new DnsProxyServerCallbackConfiguration();
int dnsProxyProcessId = Process.GetCurrentProcess().Id;
if (isRedirectorExist)
{
m_CoreProcess =
WindowsTools.CreateProcess(
redirectorAppExecutablePath,
string.Format("{0} {1}", dnsProxyProcessId, DNS_PROXY_PORT),
true);
m_CoreProcess.Start();
}
m_DnsApi.StartDnsFiltering(new DnsApiConfiguration
{
IsEnabled = true,
DnsProxySettings = dnsProxySettings,
DnsProxyServerCallbackConfiguration = dnsProxyServerCallbackConfiguration
});
Console.ReadLine();
}
finally
{
m_DnsApi.StopDnsFiltering();
if (isRedirectorExist && m_CoreProcess != null)
{
m_CoreProcess.StandardInput.WriteLine("Switching off the core sample app...");
m_CoreProcess.Kill();
#if UNINSTALL_REDIRECT_DRIVER
UninstallRedirectDriver();
#endif
}
ConsoleToFileRedirector.Stop();
}
}
public void TestDnsProxyServer()
{
DnsProxySettings currentDnsProxySettings = new DnsProxySettings();
IDnsProxyServerCallbackConfiguration callback = new DnsProxyServerCallbackConfiguration();
Assert.DoesNotThrow(() =>
{
IDnsProxyServer server = new DnsProxyServer.DnsProxyServer(currentDnsProxySettings, callback);
});
}
public void TestUpstreamOptionsConverter()
{
IDnsProxyServerCallbackConfiguration dnsCallback = new DnsProxyServerCallbackConfiguration();
DnsProxySettings currentDnsProxySettings = new DnsProxySettings();
IDnsProxyServer proxyServer = new DnsProxyServer.DnsProxyServer(currentDnsProxySettings, dnsCallback);
AGDnsApi.AGDnsProxyServerCallbacks serverCallbackNative =
DnsApiConverter.ToNativeObject(dnsCallback, proxyServer);
Assert.NotNull(serverCallbackNative);
}
public void TestGetDefaultSettings()
{
DnsProxySettings defaultDnsProxySettings = DnsApi.Instance.GetDefaultDnsProxySettings();
Assert.IsNotNull(defaultDnsProxySettings);
Assert.IsNotNull(defaultDnsProxySettings.Upstreams);
Assert.IsNotNull(defaultDnsProxySettings.Fallbacks);
Assert.IsNotNull(defaultDnsProxySettings.Listeners);
Assert.IsNotNull(defaultDnsProxySettings.EngineParams);
Assert.IsNotNull(defaultDnsProxySettings.Dns64);
}
public static void Main(string[] args)
{
string redirectorAppExecutablePath = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
REDIRECTOR_EXECUTABLE_RELATIVE_PATH);
bool isRedirectorExist = File.Exists(redirectorAppExecutablePath);
try
{
#if LOG_TO_FILE
ConsoleToFileRedirector.Start("Logs");
#endif
DnsSimpleApi.StartLogger();
DnsProxySettings dnsProxySettings = CreateDnsProxySettings();
IDnsProxyServerCallbackConfiguration dnsProxyServerCallbackConfiguration =
new DnsProxyServerCallbackConfiguration();
int dnsProxyProcessId = Process.GetCurrentProcess().Id;
if (isRedirectorExist)
{
m_CoreProcess =
WindowsTools.CreateProcess(
redirectorAppExecutablePath,
$"{dnsProxyProcessId} {DNS_PROXY_PORT}",
true);
m_CoreProcess.Start();
}
dnsProxySettings.OptimisticCache = true;
dnsProxySettings.EnableDNSSECOK = true;
DnsSimpleApi.StartDnsFiltering(new DnsApiConfiguration
{
IsEnabled = true,
DnsProxySettings = dnsProxySettings,
DnsProxyServerCallbackConfiguration = dnsProxyServerCallbackConfiguration
});
Console.ReadLine();
}
finally
{
DnsSimpleApi.StopDnsFiltering();
if (isRedirectorExist && m_CoreProcess != null)
{
m_CoreProcess.StandardInput.WriteLine("Switching off the core sample app...");
m_CoreProcess.Kill();
#if UNINSTALL_REDIRECT_DRIVER
UninstallRedirectDriver();
#endif
}
ConsoleToFileRedirector.Stop();
}
}
/// <summary>
/// Initializes the new instance of the DnsProxyServer
/// </summary>
/// <param name="dnsProxySettings">Dns proxy settings
/// (<seealso cref="DnsProxySettings"/>)</param>
/// <param name="callbackConfiguration">Callback config configuration
/// (<seealso cref="IDnsProxyServerCallbackConfiguration"/>)</param>
/// <exception cref="NotSupportedException">Thrown if current API version is not supported</exception>
public DnsProxyServer(
DnsProxySettings dnsProxySettings,
IDnsProxyServerCallbackConfiguration callbackConfiguration)
{
lock (m_SyncRoot)
{
Logger.Info("Creating the DnsProxyServer");
AGDnsApi.ValidateApi();
m_DnsProxySettings = dnsProxySettings;
m_CallbackConfiguration = callbackConfiguration;
}
}
internal static DnsProxySettings CreateDnsProxySettings()
{
DnsProxySettings dnsProxySettings = new DnsProxySettings
{
Upstreams = new List <UpstreamOptions>
{
CreateUpstreamOptions()
},
Fallbacks = new List <UpstreamOptions>
{
CreateUpstreamOptions()
},
Dns64 = new Dns64Settings
{
Upstreams = new List <UpstreamOptions>
{
CreateUpstreamOptions()
},
MaxTries = 5,
WaitTimeMs = 1000
},
BlockedResponseTtlSec = 5,
BlockingMode = AGDnsApi.ag_dnsproxy_blocking_mode.DEFAULT,
BlockIpv6 = false,
CustomBlockingIpv4 = null,
CustomBlockingIpv6 = null,
DnsCacheSize = 500,
EngineParams = new EngineParams
{
FilterParams = new List <FilterParams>
{
new FilterParams
{
Id = 0,
Data = "blablabla",
InMemory = true
}
}
},
Listeners = new List <ListenerSettings>
{
new ListenerSettings
{
EndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 45),
IsPersistent = true,
IdleTimeoutMs = 500
}
},
Ipv6Available = true
};
return(dnsProxySettings);
}
/// <summary>
/// Gets the DNS proxy settings,
/// according to the specified <see cref="pCurrentDnsProxySettings"/>
/// </summary>
/// <param name="pCurrentDnsProxySettings">DNS proxy settings
/// (<seealso cref="Func{TResult}"/>)</param>
/// <exception cref="InvalidOperationException">Thrown,
/// if cannot get the DNS proxy settings via native method</exception>
/// <returns>The <see cref="DnsProxySettings"/> object</returns>
private static DnsProxySettings GetDnsProxySettings(IntPtr pCurrentDnsProxySettings)
{
Logger.Info("Get DNS proxy settings settings");
if (pCurrentDnsProxySettings == IntPtr.Zero)
{
throw new InvalidOperationException("Cannot get the DNS proxy settings");
}
AGDnsApi.ag_dnsproxy_settings currentDnsProxySettingsC =
MarshalUtils.PtrToStructure <AGDnsApi.ag_dnsproxy_settings>(pCurrentDnsProxySettings);
DnsProxySettings currentDnsProxySettings = DnsApiConverter.FromNativeObject(currentDnsProxySettingsC);
Logger.Info("Finished getting the DNS proxy settings");
return(currentDnsProxySettings);
}
/// <summary>
/// Gets the current DNS proxy settings as a <see cref="DnsProxySettings"/> object
/// </summary>
/// <returns>Current DNS proxy settings
/// (<seealso cref="DnsProxySettings"/>)</returns>
/// <exception cref="InvalidOperationException">Thrown,
/// if cannot get the current dns proxy settings via native method</exception>
public DnsProxySettings GetCurrentDnsProxySettings()
{
LOG.Info("Get current DnsProxyServer settings");
lock (m_SyncRoot)
{
if (!IsStarted)
{
LOG.Info("DnsProxyServer is not started, doing nothing");
return(null);
}
DnsProxySettings currentDnsProxySettings =
GetDnsProxySettings(() => AGDnsApi.ag_dnsproxy_get_settings(m_pProxyServer));
return(currentDnsProxySettings);
}
}
private static void AddDnsSuffixesAndDefaultFallbacks(DnsProxySettings dnsProxySettings)
{
List <string> dnsSuffixes = GetSystemDNSSuffixes();
if (dnsProxySettings.FallbackDomains == null)
{
dnsProxySettings.FallbackDomains = new List <string>();
}
List <string> fallbackDomains = dnsProxySettings.FallbackDomains;
List <string> preparedDnsSuffixes = dnsSuffixes.Select(x => $"*.{x}").ToList();
fallbackDomains.AddRange(preparedDnsSuffixes);
dnsProxySettings.FallbackDomains = fallbackDomains.Distinct().ToList();
}
/// <summary>
/// Gets the default DNS proxy settings as a <see cref="DnsProxySettings"/> object
/// </summary>
/// <returns>Current DNS proxy settings
/// (<seealso cref="DnsProxySettings"/>)</returns>
/// <exception cref="InvalidOperationException">Thrown,
/// if cannot get the default dns proxy settings via native method</exception>
public DnsProxySettings GetDefaultDnsProxySettings()
{
lock (SYNC_ROOT)
{
try
{
LOG.InfoFormat("Getting default DNS proxy settings");
DnsProxySettings dnsProxySettings =
Dns.DnsProxyServer.DnsProxyServer.GetDefaultDnsProxySettings();
LOG.InfoFormat("Getting default DNS proxy settings has been successfully completed");
return(dnsProxySettings);
}
catch (Exception ex)
{
LOG.ErrorFormat("Getting default DNS proxy settings failed with an error", ex);
throw;
}
}
}
internal static DnsProxySettings FromNativeObject(
AGDnsApi.ag_dnsproxy_settings dnsProxySettingsC)
{
List <UpstreamOptions> upstreams = MarshalUtils.AgListToList <AGDnsApi.ag_upstream_options, UpstreamOptions>(
dnsProxySettingsC.upstreams,
FromNativeObject);
List <UpstreamOptions> fallbacks = MarshalUtils.AgListToList <AGDnsApi.ag_upstream_options, UpstreamOptions>(
dnsProxySettingsC.fallbacks,
FromNativeObject);
List <string> fallbackDomains = MarshalUtils.AgListToList <IntPtr, string>(
dnsProxySettingsC.fallbackDomains,
MarshalUtils.PtrToString);
AGDnsApi.ag_dns64_settings dns64C =
MarshalUtils.PtrToStructure <AGDnsApi.ag_dns64_settings>(dnsProxySettingsC.pDns64);
Dns64Settings dns64 = FromNativeObject(dns64C);
EngineParams engineParams = FromNativeObject(dnsProxySettingsC.FilterParams);
List <ListenerSettings> listeners =
MarshalUtils.AgListToList <AGDnsApi.ag_listener_settings, ListenerSettings>(
dnsProxySettingsC.listeners,
FromNativeObject);
AGDnsApi.ag_outbound_proxy_settings outboundProxySettingsC =
MarshalUtils.PtrToStructure <AGDnsApi.ag_outbound_proxy_settings>(dnsProxySettingsC.outbound_proxy);
OutboundProxySettings outboundProxySettings =
FromNativeObject(outboundProxySettingsC);
DnsProxySettings dnsProxySettings = new DnsProxySettings
{
Upstreams = upstreams,
Fallbacks = fallbacks,
FallbackDomains = fallbackDomains,
Dns64 = dns64,
EngineParams = engineParams,
Listeners = listeners,
OutboundProxySettings = outboundProxySettings
};
MarshalUtils.CopyFieldsToProperties(dnsProxySettingsC, dnsProxySettings);
MarshalUtils.AllPtrsToStrings(dnsProxySettingsC, dnsProxySettings);
return(dnsProxySettings);
}
public void TestGetCurrentDnsProxySettings()
{
DnsProxySettings defaultDnsProxySettings = DnsApi.Instance.GetDefaultDnsProxySettings();
DnsApi.Instance.StartDnsFiltering(new DnsApiConfiguration
{
IsEnabled = true,
DnsProxySettings = defaultDnsProxySettings,
DnsProxyServerCallbackConfiguration = new DnsProxyServerCallbackConfiguration()
});
DnsProxySettings currentDnsProxySettings = DnsApi.Instance.GetCurrentDnsProxySettings();
Assert.IsNotNull(currentDnsProxySettings);
Assert.IsNotNull(currentDnsProxySettings.Upstreams);
Assert.IsNotNull(currentDnsProxySettings.Fallbacks);
Assert.IsNotNull(currentDnsProxySettings.Listeners);
Assert.IsNotNull(currentDnsProxySettings.EngineParams);
Assert.IsNotNull(currentDnsProxySettings.Dns64);
DnsApi.Instance.StopDnsFiltering();
currentDnsProxySettings = DnsApi.Instance.GetCurrentDnsProxySettings();
Assert.IsNull(currentDnsProxySettings);
}
/// <summary>
/// Gets the current DNS proxy settings as a <see cref="DnsProxySettings"/> object
/// </summary>
/// <returns>Current DNS proxy settings
/// (<seealso cref="DnsProxySettings"/>)</returns>
/// <exception cref="InvalidOperationException">Thrown,
/// if cannot get the current dns proxy settings via native method</exception>
public DnsProxySettings GetCurrentDnsProxySettings()
{
lock (SYNC_ROOT)
{
try
{
LOG.InfoFormat("Getting current DNS proxy settings");
if (m_DnsProxyServer == null)
{
return(null);
}
DnsProxySettings dnsProxySettings = m_DnsProxyServer.GetCurrentDnsProxySettings();
LOG.InfoFormat("Getting current DNS proxy settings has been successfully completed");
return(dnsProxySettings);
}
catch (Exception ex)
{
LOG.ErrorFormat("Getting current DNS proxy settings failed with an error", ex);
throw;
}
}
}
public void TestDnsProxySettingsConverter()
{
DnsProxySettings dnsSettings = new DnsProxySettings
{
Upstreams = new List <UpstreamOptions>
{
new UpstreamOptions
{
Id = 1,
Bootstrap = new List <string>()
},
new UpstreamOptions
{
Id = 2,
Bootstrap = new List <string>()
},
new UpstreamOptions
{
Id = 3,
Bootstrap = new List <string>
{
"bootStrapBegin",
"bootStrapEnd"
}
}
},
Fallbacks = new List <UpstreamOptions>()
{
new UpstreamOptions
{
Bootstrap = new List <string>()
}
},
BlockedResponseTtlSec = 64,
Dns64 = new Dns64Settings
{
Upstreams = new List <UpstreamOptions>()
},
EngineParams = new EngineParams
{
FilterParams = new List <FilterParams>()
},
Listeners = new List <ListenerSettings>
{
new ListenerSettings
{
EndPoint = new IPEndPoint(1234567, 9898)
}
},
FallbackDomains = new List <string>
{
"Test.com"
},
Ipv6Available = true,
BlockIpv6 = true,
AdblockRulesBlockingMode = AGDnsApi.ag_dnsproxy_blocking_mode.AGBM_ADDRESS,
HostsRulesBlockingMode = AGDnsApi.ag_dnsproxy_blocking_mode.AGBM_ADDRESS,
CustomBlockingIpv4 = "1.2.3.4",
CustomBlockingIpv6 = "::AA",
DnsCacheSize = 23,
OptimisticCache = true
};
Queue <IntPtr> allocatedPointers = new Queue <IntPtr>();
AGDnsApi.ag_dnsproxy_settings nativeDnsSettings =
DnsApiConverter.ToNativeObject(dnsSettings, allocatedPointers);
Assert.AreNotEqual(IntPtr.Zero, nativeDnsSettings.fallbacks.entries);
Assert.AreNotEqual(IntPtr.Zero, nativeDnsSettings.fallbackDomains.entries);
Assert.AreNotEqual(IntPtr.Zero, nativeDnsSettings.listeners.entries);
Assert.AreNotEqual(IntPtr.Zero, nativeDnsSettings.upstreams.entries);
Assert.AreEqual(nativeDnsSettings.BlockedResponseTtlSec, dnsSettings.BlockedResponseTtlSec);
Assert.AreEqual(nativeDnsSettings.Ipv6Available, dnsSettings.Ipv6Available);
Assert.AreEqual(nativeDnsSettings.BlockIpv6, dnsSettings.BlockIpv6);
Assert.AreEqual(nativeDnsSettings.AdblockRulesBlockingMode, dnsSettings.AdblockRulesBlockingMode);
Assert.AreEqual(nativeDnsSettings.HostsRulesBlockingMode, dnsSettings.HostsRulesBlockingMode);
Assert.AreEqual(MarshalUtils.PtrToString(nativeDnsSettings.CustomBlockingIpv4), dnsSettings.CustomBlockingIpv4);
Assert.AreEqual(MarshalUtils.PtrToString(nativeDnsSettings.CustomBlockingIpv6), dnsSettings.CustomBlockingIpv6);
Assert.AreEqual(nativeDnsSettings.DnsCacheSize, dnsSettings.DnsCacheSize);
Assert.AreEqual(nativeDnsSettings.OptimisticCache, dnsSettings.OptimisticCache);
DnsProxySettings dnsSettingsConverted = DnsApiConverter.FromNativeObject(nativeDnsSettings);
Assert.AreEqual(dnsSettings.FallbackDomains, dnsSettingsConverted.FallbackDomains);
Assert.AreEqual(dnsSettings.BlockedResponseTtlSec, dnsSettingsConverted.BlockedResponseTtlSec);
Assert.AreEqual(dnsSettings.CustomBlockingIpv4, dnsSettingsConverted.CustomBlockingIpv4);
Assert.AreEqual(dnsSettings.CustomBlockingIpv6, dnsSettingsConverted.CustomBlockingIpv6);
Assert.AreEqual(dnsSettings.AdblockRulesBlockingMode, dnsSettingsConverted.AdblockRulesBlockingMode);
Assert.AreEqual(dnsSettings.HostsRulesBlockingMode, dnsSettingsConverted.HostsRulesBlockingMode);
bool isUpstreamsEqual = CollectionUtils.CollectionsEquals(dnsSettingsConverted.Upstreams, dnsSettings.Upstreams);
Assert.IsTrue(isUpstreamsEqual);
}
/// <summary>
/// Reloads DNS filtering
/// <param name="newDnsApiConfiguration">Dns proxy configuration
/// (<seealso cref="DnsApiConfiguration"/>)</param>
/// <param name="force">Determines, whether the DNS filtering must be reloaded,
/// independently of whether configuration changed or not</param>
/// <exception cref="ArgumentNullException">Thrown, if <see cref="newDnsApiConfiguration"/>
/// is not specified</exception>
/// <exception cref="ArgumentException">Thrown, if <see cref="DnsProxySettings"/>
/// is not specified within the <see cref="newDnsApiConfiguration"/></exception>
/// <exception cref="NotSupportedException">Thrown
/// if current API version is not supported</exception>
/// <exception cref="InvalidOperationException">Thrown, if cannot starting the proxy server
/// for any reason</exception>
/// <exception cref="InvalidOperationException">Thrown, if cannot closing the proxy server
/// for any reason</exception>
/// </summary>
public void ReloadDnsFiltering(DnsApiConfiguration newDnsApiConfiguration, bool force)
{
lock (SYNC_ROOT)
{
IDnsProxyServer newDnsProxyServer = null;
try
{
LOG.InfoFormat("Reloading the DNS filtering");
if (m_DnsProxyServer == null ||
m_CurrentDnsProxySettings == null)
{
LOG.InfoFormat(
"Start DNS filtering, because the DNS server is not started and/or configurations are not set");
StartDnsFiltering(newDnsApiConfiguration);
return;
}
if (newDnsApiConfiguration == null)
{
throw new ArgumentNullException(
"newDnsApiConfiguration",
"newDnsApiConfiguration is not specified");
}
if (newDnsApiConfiguration.DnsProxySettings == null)
{
throw new ArgumentException(
"DnsProxySettings is not initialized",
"newDnsApiConfiguration");
}
bool isConfigurationChanged = !m_CurrentDnsProxySettings.Equals(newDnsApiConfiguration.DnsProxySettings);
if (!force &&
!isConfigurationChanged)
{
LOG.InfoFormat("The DNS server configuration hasn't been changed, no need to reload");
return;
}
newDnsProxyServer = new Dns.DnsProxyServer.DnsProxyServer(
newDnsApiConfiguration.DnsProxySettings,
newDnsApiConfiguration.DnsProxyServerCallbackConfiguration);
m_DnsProxyServer.Stop();
m_DnsProxyServer = newDnsProxyServer;
if (newDnsApiConfiguration.IsEnabled)
{
LOG.InfoFormat("DNS filtering is enabled, starting DNS proxy server");
m_DnsProxyServer.Start();
}
m_CurrentDnsProxySettings = newDnsApiConfiguration.DnsProxySettings;
LOG.InfoFormat("Reloading the DNS filtering has been successfully completed");
}
catch (Exception ex)
{
LOG.ErrorFormat("Reloading the DNS filtering failed with an error", ex);
if (newDnsProxyServer != null &&
newDnsProxyServer.IsStarted)
{
// if the new DNS proxy server has been already started we should stop it,
// otherwise - let the existed proxy server works
StopDnsFiltering();
}
throw;
}
}
}
private static DnsProxySettings CreateDnsProxySettings()
{
List <ListenerSettings> listeners = new List <ListenerSettings>();
foreach (AGDnsApi.ag_listener_protocol protocol in
(AGDnsApi.ag_listener_protocol[])Enum.GetValues(typeof(AGDnsApi.ag_listener_protocol)))
{
foreach (IPAddress listenerAddress in new [] { IPAddress.Loopback, IPAddress.IPv6Loopback })
{
ListenerSettings listener = new ListenerSettings
{
EndPoint = new IPEndPoint(listenerAddress, DNS_PROXY_PORT),
Protocol = protocol,
IsPersistent = true,
IdleTimeoutMs = 3000
};
listeners.Add(listener);
}
}
DnsProxySettings dnsProxySettings = new DnsProxySettings
{
Upstreams = new List <UpstreamOptions>
{
CreateUpstreamOptions()
},
Fallbacks = new List <UpstreamOptions>(),
FallbackDomains = new List <string>(),
Dns64 = new Dns64Settings
{
Upstreams = new List <UpstreamOptions>(),
MaxTries = 5,
WaitTimeMs = 2000
},
BlockedResponseTtlSec = 0,
AdblockRulesBlockingMode = AGDnsApi.ag_dnsproxy_blocking_mode.AGBM_REFUSED,
HostsRulesBlockingMode = AGDnsApi.ag_dnsproxy_blocking_mode.AGBM_REFUSED,
BlockIpv6 = true,
CustomBlockingIpv4 = null,
CustomBlockingIpv6 = null,
DnsCacheSize = 128,
EngineParams = new EngineParams
{
FilterParams = new List <FilterParams>
{
new FilterParams
{
Id = 0,
Data = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
SDNS_FILTER_RELATIVE_PATH),
InMemory = false
}
}
},
Listeners = listeners,
OutboundProxySettings = new OutboundProxySettings
{
Protocol = AGDnsApi.ag_outbound_proxy_protocol.AGOPP_SOCKS5,
Address = "127.0.0.1",
AuthInfo = new OutboundProxyAuthInfo
{
Password = "******",
Username = "******"
},
Port = 6754,
TrustAnyCertificate = false
},
Ipv6Available = false,
OptimisticCache = false,
EnableDNSSECOK = false,
EnableRetransmissionHandling = false
};
return(dnsProxySettings);
}
