public async Task SendPingAsyncWithIPAddressAndTimeoutAndBufferAndPingOptions_Unix(AddressFamily addressFamily) { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(addressFamily); if (localIpAddress == null) { // No local address for given address family. return; } byte[] buffer = TestSettings.PayloadAsBytes; await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress, TestSettings.PingTimeout, buffer, new PingOptions()), (pingReply) => { PingResultValidator(pingReply, localIpAddress); // Non-root pings cannot send arbitrary data in the buffer, and do not receive it back in the PingReply. if (Capability.CanUseRawSockets(localIpAddress.AddressFamily)) { Assert.Equal(buffer, pingReply.Buffer); } else { Assert.Equal(Array.Empty <byte>(), pingReply.Buffer); } }); }
public async Task SendPingAsync_InvalidArgs() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); Ping p = new Ping(); // Null address AssertExtensions.Throws <ArgumentNullException>("address", () => { p.SendPingAsync((IPAddress)null); }); AssertExtensions.Throws <ArgumentNullException>("hostNameOrAddress", () => { p.SendPingAsync((string)null); }); AssertExtensions.Throws <ArgumentNullException>("address", () => { p.SendAsync((IPAddress)null, null); }); AssertExtensions.Throws <ArgumentNullException>("hostNameOrAddress", () => { p.SendAsync((string)null, null); }); AssertExtensions.Throws <ArgumentNullException>("address", () => { p.Send((IPAddress)null); }); AssertExtensions.Throws <ArgumentNullException>("hostNameOrAddress", () => { p.Send((string)null); }); // Invalid address AssertExtensions.Throws <ArgumentException>("address", () => { p.SendPingAsync(IPAddress.Any); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.SendPingAsync(IPAddress.IPv6Any); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.SendAsync(IPAddress.Any, null); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.SendAsync(IPAddress.IPv6Any, null); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.Send(IPAddress.Any); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.Send(IPAddress.IPv6Any); }); // Negative timeout AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendPingAsync(localIpAddress, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendPingAsync(TestSettings.LocalHost, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendAsync(localIpAddress, -1, null); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendAsync(TestSettings.LocalHost, -1, null); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.Send(localIpAddress, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.Send(TestSettings.LocalHost, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.Send(localIpAddress, TimeSpan.FromMilliseconds(-1), default, default); });
public async Task SendPingAsyncWithIPAddressAndTimeout() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress, TestSettings.PingTimeout), (pingReply) => { PingResultValidator(pingReply, localIpAddress); }); }
public async Task SendPingAsyncWithIPAddress_AddressAsString() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress.ToString()), (pingReply) => { PingResultValidator(pingReply, localIpAddress); }); }
public async Task SendPingAsyncWithHostAndTimeoutAndBuffer() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); byte[] buffer = TestSettings.PayloadAsBytes; await SendBatchPingAsync( (ping) => ping.SendPingAsync(TestSettings.LocalHost, TestSettings.PingTimeout, buffer), (pingReply) => { PingResultValidator(pingReply, localIpAddress); Assert.Equal(buffer, pingReply.Buffer); }); }
public static async Task Sends_ReuseInstance_Hostname() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); using (Ping p = new Ping()) { for (int i = 0; i < 3; i++) { PingReply pingReply = p.Send(TestSettings.LocalHost); PingResultValidator(pingReply, localIpAddress); } } }
public async Task SendPingAsyncWithIPAddressAndTimeoutAndBuffer() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); byte[] buffer = GetPingPayload(localIpAddress.AddressFamily); await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress, TestSettings.PingTimeout, buffer), (pingReply) => { PingResultValidator(pingReply, localIpAddress); Assert.Equal(buffer, pingReply.Buffer); }); }
public static async Task SendAsyncs_ReuseInstance_Hostname() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); using (Ping p = new Ping()) { TaskCompletionSource <bool> tcs = null; PingCompletedEventArgs ea = null; p.PingCompleted += (s, e) => { ea = e; tcs.TrySetResult(true); }; Action reset = () => { ea = null; tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously); }; // Several normal iterations for (int i = 0; i < 3; i++) { reset(); p.SendAsync(TestSettings.LocalHost, null); await tcs.Task; Assert.NotNull(ea); PingResultValidator(ea.Reply, localIpAddress); } // Several canceled iterations for (int i = 0; i < 3; i++) { reset(); p.SendAsync(TestSettings.LocalHost, null); p.SendAsyncCancel(); // will block until operation can be started again await tcs.Task; bool cancelled = ea.Cancelled; Exception error = ea.Error; PingReply reply = ea.Reply; Assert.True(cancelled ^ (error != null) ^ (reply != null), "Cancelled: " + cancelled + (error == null ? "" : (Environment.NewLine + "Error Message: " + error.Message + Environment.NewLine + "Error Inner Exception: " + error.InnerException)) + (reply == null ? "" : (Environment.NewLine + "Reply Address: " + reply.Address + Environment.NewLine + "Reply Status: " + reply.Status))); } } }
public async Task SendPingAsyncWithIPAddressAndTimeoutAndBufferAndPingOptions() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); var options = new PingOptions(); byte[] buffer = TestSettings.PayloadAsBytes; await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress, TestSettings.PingTimeout, buffer, options), (pingReply) => { PingResultValidator(pingReply, localIpAddress); Assert.Equal(buffer, pingReply.Buffer); Assert.InRange(pingReply.RoundtripTime, 0, long.MaxValue); }); }
public async Task SendPingAsync_InvalidArgs() { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); Ping p = new Ping(); // Null address AssertExtensions.Throws <ArgumentNullException>("address", () => { p.SendPingAsync((IPAddress)null); }); AssertExtensions.Throws <ArgumentNullException>("hostNameOrAddress", () => { p.SendPingAsync((string)null); }); AssertExtensions.Throws <ArgumentNullException>("address", () => { p.SendAsync((IPAddress)null, null); }); AssertExtensions.Throws <ArgumentNullException>("hostNameOrAddress", () => { p.SendAsync((string)null, null); }); AssertExtensions.Throws <ArgumentNullException>("address", () => { p.Send((IPAddress)null); }); AssertExtensions.Throws <ArgumentNullException>("hostNameOrAddress", () => { p.Send((string)null); }); // Invalid address AssertExtensions.Throws <ArgumentException>("address", () => { p.SendPingAsync(IPAddress.Any); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.SendPingAsync(IPAddress.IPv6Any); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.SendAsync(IPAddress.Any, null); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.SendAsync(IPAddress.IPv6Any, null); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.Send(IPAddress.Any); }); AssertExtensions.Throws <ArgumentException>("address", () => { p.Send(IPAddress.IPv6Any); }); // Negative timeout AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendPingAsync(localIpAddress, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendPingAsync(TestSettings.LocalHost, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendAsync(localIpAddress, -1, null); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.SendAsync(TestSettings.LocalHost, -1, null); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.Send(localIpAddress, -1); }); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { p.Send(TestSettings.LocalHost, -1); }); // Null byte[] AssertExtensions.Throws <ArgumentNullException>("buffer", () => { p.SendPingAsync(localIpAddress, 0, null); }); AssertExtensions.Throws <ArgumentNullException>("buffer", () => { p.SendPingAsync(TestSettings.LocalHost, 0, null); }); AssertExtensions.Throws <ArgumentNullException>("buffer", () => { p.SendAsync(localIpAddress, 0, null, null); }); AssertExtensions.Throws <ArgumentNullException>("buffer", () => { p.SendAsync(TestSettings.LocalHost, 0, null, null); }); AssertExtensions.Throws <ArgumentNullException>("buffer", () => { p.Send(localIpAddress, 0, null); }); AssertExtensions.Throws <ArgumentNullException>("buffer", () => { p.Send(TestSettings.LocalHost, 0, null); }); // Too large byte[] AssertExtensions.Throws <ArgumentException>("buffer", () => { p.SendPingAsync(localIpAddress, 1, new byte[65501]); }); AssertExtensions.Throws <ArgumentException>("buffer", () => { p.SendPingAsync(TestSettings.LocalHost, 1, new byte[65501]); }); AssertExtensions.Throws <ArgumentException>("buffer", () => { p.SendAsync(localIpAddress, 1, new byte[65501], null); }); AssertExtensions.Throws <ArgumentException>("buffer", () => { p.SendAsync(TestSettings.LocalHost, 1, new byte[65501], null); }); AssertExtensions.Throws <ArgumentException>("buffer", () => { p.Send(localIpAddress, 1, new byte[65501]); }); AssertExtensions.Throws <ArgumentException>("buffer", () => { p.Send(TestSettings.LocalHost, 1, new byte[65501]); }); }
public async Task SendPingAsyncWithIPAddress(AddressFamily addressFamily) { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(addressFamily); if (localIpAddress == null) { // No local address for given address family. return; } await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress), (pingReply) => { PingResultValidator(pingReply, localIpAddress); }); }
public async Task SendPingAsyncWithHostAndTtlAndFragmentPingOptions(bool fragment) { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); byte[] buffer = TestSettings.PayloadAsBytes; PingOptions options = new PingOptions(); options.Ttl = 32; options.DontFragment = fragment; await SendBatchPingAsync( (ping) => ping.SendPingAsync(TestSettings.LocalHost, TestSettings.PingTimeout, buffer, options), (pingReply) => { PingResultValidator(pingReply, localIpAddress); }); }
public async Task SendPingAsyncWithIPAddressAndTimeoutAndBufferAndPingOptions_Unix(AddressFamily addressFamily) { IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(addressFamily); if (localIpAddress == null) { // No local address for given address family. return; } byte[] buffer = GetPingPayload(localIpAddress.AddressFamily); await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress, TestSettings.PingTimeout, buffer, new PingOptions()), (pingReply) => { PingResultValidator(pingReply, localIpAddress); Assert.Equal(buffer, pingReply.Buffer); }); }
public async Task SendPingAsyncWithIPAddressAndTimeoutAndBuffer_Unix() { byte[] buffer = TestSettings.PayloadAsBytes; IPAddress localIpAddress = await TestSettings.GetLocalIPAddressAsync(); await SendBatchPingAsync( (ping) => ping.SendPingAsync(localIpAddress, TestSettings.PingTimeout, buffer), (pingReply) => { PingResultValidator(pingReply, localIpAddress); // Non-root pings cannot send arbitrary data in the buffer, and do not receive it back in the PingReply. if (Capability.CanUseRawSockets(localIpAddress.AddressFamily) || PlatformDetection.IsOSXLike) { Assert.Equal(buffer, pingReply.Buffer); } else { Assert.Equal(Array.Empty <byte>(), pingReply.Buffer); } }); }
[PlatformSpecific(TestPlatforms.AnyUnix)] // Tests un-priviledged Ping support on Unix public static async Task PacketSizeIsRespected(int payloadSize) { IPAddress localAddress = await TestSettings.GetLocalIPAddressAsync(); bool ipv4 = localAddress.AddressFamily == AddressFamily.InterNetwork; string arguments = UnixCommandLinePing.ConstructCommandLine(payloadSize, localAddress.ToString(), ipv4); string utilityPath = (localAddress.AddressFamily == AddressFamily.InterNetwork) ? UnixCommandLinePing.Ping4UtilityPath : UnixCommandLinePing.Ping6UtilityPath; var p = new Process(); p.StartInfo.FileName = utilityPath; p.StartInfo.Arguments = arguments; p.StartInfo.UseShellExecute = false; p.StartInfo.RedirectStandardOutput = true; var stdOutLines = new List <string>(); p.OutputDataReceived += new DataReceivedEventHandler( delegate(object sendingProcess, DataReceivedEventArgs outputLine) { stdOutLines.Add(outputLine.Data); }); p.StartInfo.RedirectStandardError = true; var stdErrLines = new List <string>(); p.ErrorDataReceived += new DataReceivedEventHandler( delegate(object sendingProcess, DataReceivedEventArgs errorLine) { stdErrLines.Add(errorLine.Data); }); p.Start(); p.BeginOutputReadLine(); p.BeginErrorReadLine(); // There are multiple issues with ping6 in macOS 10.12 (Sierra), see https://github.com/dotnet/corefx/issues/26358. bool isPing6OnMacSierra = utilityPath.Equals(UnixCommandLinePing.Ping6UtilityPath) && RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && !PlatformDetection.IsMacOsHighSierraOrHigher; string pingOutput; if (!p.WaitForExit(TestSettings.PingTimeout)) { // Workaround known issues with ping6 in macOS 10.12 if (isPing6OnMacSierra) { return; } pingOutput = string.Join("\n", stdOutLines); string stdErr = string.Join("\n", stdErrLines); throw new Exception( $"[{utilityPath} {arguments}] process did not exit in {TestSettings.PingTimeout} ms.\nStdOut:[{pingOutput}]\nStdErr:[{stdErr}]"); } // Ensure standard output and error are flushed p.WaitForExit(); pingOutput = string.Join("\n", stdOutLines); var exitCode = p.ExitCode; if (exitCode != 0) { // Workaround known issues with ping6 in macOS 10.12 if (isPing6OnMacSierra) { return; } string stdErr = string.Join("\n", stdErrLines); throw new Exception( $"[{utilityPath} {arguments}] process exit code is {exitCode}.\nStdOut:[{pingOutput}]\nStdErr:[{stdErr}]"); } try { // Validate that the returned data size is correct. // It should be equal to the bytes we sent plus the size of the ICMP header. int receivedBytes = ParseReturnedPacketSize(pingOutput); int expected = Math.Max(16, payloadSize) + IcmpHeaderLengthInBytes; Assert.Equal(expected, receivedBytes); // Validate that we only sent one ping with the "-c 1" argument. int numPingsSent = ParseNumPingsSent(pingOutput); Assert.Equal(1, numPingsSent); long rtt = UnixCommandLinePing.ParseRoundTripTime(pingOutput); Assert.InRange(rtt, 0, long.MaxValue); } catch (Exception e) { string stdErr = string.Join("\n", stdErrLines); throw new Exception( $"Parse error for [{utilityPath} {arguments}] process exit code is {exitCode}.\nStdOut:[{pingOutput}]\nStdErr:[{stdErr}]", e); } }
[PlatformSpecific(TestPlatforms.AnyUnix)] // Tests un-priviledged Ping support on Unix public static async Task PacketSizeIsRespected(int payloadSize) { var stdOutLines = new List <string>(); var stdErrLines = new List <string>(); Process p = ConstructPingProcess(await TestSettings.GetLocalIPAddressAsync(), payloadSize, 1000); p.StartInfo.RedirectStandardOutput = true; p.OutputDataReceived += delegate(object sendingProcess, DataReceivedEventArgs outputLine) { stdOutLines.Add(outputLine.Data); }; p.StartInfo.RedirectStandardError = true; p.ErrorDataReceived += delegate(object sendingProcess, DataReceivedEventArgs errorLine) { stdErrLines.Add(errorLine.Data); }; p.Start(); p.BeginOutputReadLine(); p.BeginErrorReadLine(); string pingOutput; if (!p.WaitForExit(TestSettings.PingTimeout)) { pingOutput = string.Join("\n", stdOutLines); string stdErr = string.Join("\n", stdErrLines); throw new Exception( $"[{p.StartInfo.FileName} {p.StartInfo.Arguments}] process did not exit in {TestSettings.PingTimeout} ms.\nStdOut:[{pingOutput}]\nStdErr:[{stdErr}]"); } // Ensure standard output and error are flushed p.WaitForExit(); pingOutput = string.Join("\n", stdOutLines); var exitCode = p.ExitCode; if (exitCode != 0) { string stdErr = string.Join("\n", stdErrLines); throw new Exception( $"[{p.StartInfo.FileName} {p.StartInfo.Arguments}] process exit code is {exitCode}.\nStdOut:[{pingOutput}]\nStdErr:[{stdErr}]"); } try { // Validate that the returned data size is correct. // It should be equal to the bytes we sent plus the size of the ICMP header. int receivedBytes = ParseReturnedPacketSize(pingOutput); int expected = Math.Max(16, payloadSize) + IcmpHeaderLengthInBytes; Assert.Equal(expected, receivedBytes); // Validate that we only sent one ping with the "-c 1" argument. int numPingsSent = ParseNumPingsSent(pingOutput); Assert.Equal(1, numPingsSent); long rtt = UnixCommandLinePing.ParseRoundTripTime(pingOutput); Assert.InRange(rtt, 0, long.MaxValue); } catch (Exception e) { string stdErr = string.Join("\n", stdErrLines); throw new Exception( $"Parse error for [{p.StartInfo.FileName} {p.StartInfo.Arguments}] process exit code is {exitCode}.\nStdOut:[{pingOutput}]\nStdErr:[{stdErr}]", e); } }