public void ReadAndPing(string path)
{
File.OpenRead(path);
ConsoleKeyInfo btn;
do // Начала цикла
{
string ip = File.ReadLines(path);
while (true) //читаем в ip строки из файла в path
{
//Console.WriteLine(ip);
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
options.Ttl = 60; //Продолжительность жизни пакета в секундах
int timeout = 120; //Таймаут выводется в ответе reply.RoundtripTime
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; //Строка длиной 32 байта
byte[] buffer = Encoding.ASCII.GetBytes(data); //Преобразование строки в байты, выводится reply.Buffer.Length
PingReply reply = pingSender.Send(ip, timeout, buffer, options);
Console.WriteLine("Сервер: {0} Время={1} TTL={2}", reply.Address.ToString(), reply.RoundtripTime, reply.Options.Ttl); //Выводим всё на консоль
//ConsoleKeyInfo btn = Console.ReadKey(); //Создаём переменную которая хранит метод Описывающий нажатую клавишу консоли
//if (btn.Key == ConsoleKey.Escape) break;
}
// ConsoleKeyInfo btn = Console.ReadKey(); //Создаём переменную которая хранит метод Описывающий нажатую клавишу консоли
// if (btn.Key == ConsoleKey.Escape) break;
btn = Console.ReadKey(); //Переенная для чтения нажатия клавиши
}
while (btn.Key == ConsoleKey.Escape); //Чтение нажатия клавиши.
}
public static bool checkInternetConnection()
{
Ping myPing = new Ping();
String host = "google.com";
byte[] buffer = new byte[5];
int timeout = 50;
PingOptions pingOptions = new PingOptions();
try
{
PingReply reply = myPing.Send(host, timeout, buffer, pingOptions);
if (reply.Status == IPStatus.Success)
{
return true;
}
}
catch (PingException exp)
{
Logs.system("Intenet connection not available: " + exp.Message, Logs.TYPE_ERROR, exp);
return false;
}
catch (Exception exp)
{
Logs.system("Internet connection not available: " + exp.Message, Logs.TYPE_ERROR, exp);
return false;
}
return false;
}
public static PingResult PingHost(string host, int timeout = 1000, int pingCount = 4, int waitTime = 100)
{
PingResult pingResult = new PingResult();
IPAddress address = GetIpFromHost(host);
byte[] buffer = new byte[32];
PingOptions pingOptions = new PingOptions(128, true);
using (Ping ping = new Ping())
{
for (int i = 0; i < pingCount; i++)
{
try
{
PingReply pingReply = ping.Send(address, timeout, buffer, pingOptions);
if (pingReply != null)
{
pingResult.PingReplyList.Add(pingReply);
}
}
catch (Exception e)
{
DebugHelper.WriteException(e);
}
if (waitTime > 0 && i + 1 < pingCount)
{
Thread.Sleep(waitTime);
}
}
}
return pingResult;
}
public static int Main(string[] args)
{
try {
Arguments CommandLine=new Arguments(args);
if (CommandLine["ip"]!=null) {
string pingIP = CommandLine["ip"];
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
options.DontFragment=true;
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
PingReply reply = pingSender.Send(pingIP,timeout,buffer,options);
if (reply.Status==IPStatus.Success) {
WriteToConsole("RoundTrip time: "+reply.RoundtripTime);
} else if (reply.Status==IPStatus.TimedOut) {
return (int) ExitCode.Timeout;
}
} else {
printHelp();
}
return (int) ExitCode.Success;
} catch (Exception) {
return (int) ExitCode.Error;
}
}
private void buttonPing_Click(object sender, EventArgs e)
{
this.listBoxResult.Items.Clear();
//远程服务器IP
string ipString = this.textBoxRemoteIp.Text.ToString().Trim();
//构造Ping实例
Ping pingSender = new Ping();
//Ping选项设置
PingOptions options = new PingOptions();
options.DontFragment = true;
//测试数据
string data = "test data abcabc";
byte[] buffer = Encoding.ASCII.GetBytes(data);
//设置超时时间
int timeout = 120;
//调用同步send方法发送数据，将返回结果保存至PingReply实例
PingReply reply = pingSender.Send(ipString, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
listBoxResult.Items.Add("答复的主机地址: " + reply.Address.ToString());
listBoxResult.Items.Add("往返时间: " + reply.RoundtripTime);
listBoxResult.Items.Add("生存时间（TTL）: " + reply.Options.Ttl);
listBoxResult.Items.Add("是否控制数据包的分段: " + reply.Options.DontFragment);
listBoxResult.Items.Add("缓冲区大小: " + reply.Buffer.Length);
}
else
{
listBoxResult.Items.Add(reply.Status.ToString());
}
}
public static void isValidDomain()
{
try
{
Ping pingsender = new Ping();
PingOptions options = new PingOptions(128, true);
string data = "aaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
/*PingReply reply = pingsender.Send(Classes.variablen.domain);
if (reply.Status == IPStatus.Success)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Domain wurde gefunden!");
Console.ForegroundColor = ConsoleColor.Gray;
}
else if (reply.Status == IPStatus.TimedOut)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Domain wurde nicht gefunden!");
Console.ForegroundColor = ConsoleColor.Gray;
}*/
}
catch (Exception ex)
{
Classes.logger._elogger(ex);
}
}
bool Ping(string host)
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 500;
PingReply reply = pingSender.Send(host, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
Console.WriteLine("Ping successful, getting HTTP response code");
return true;
}
else
{
Console.WriteLine("Ping Failed, server is either down or took too long to respond.");
return false;
}
}
public static bool isAlive(string IP)
{
try
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
options.DontFragment = true;
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 10;
PingReply reply = pingSender.Send(IP, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
return (true);
}
else
{
Settings.SetLog("Failed to ping " + IP);
return (false);
}
}
catch (Exception e)
{
Settings.SetLog("Failed to ping " + IP);
return (false);
}
}
/// <summary>
/// Permet de tester la bonne connectivité avec une adresse IP.
/// </summary>
/// <param name="IP"></param>
/// <returns></returns>
public static Boolean CheckConnectionIpInformations(string IP)
{
if (!String.IsNullOrEmpty(IP))
{
using (Ping pingSender = new Ping())
{
PingOptions options = new PingOptions();
options.DontFragment = true;
String data = new String('a', 32);
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 20;
try
{
PingReply reply = pingSender.Send(IP, timeout, buffer, options);
if (reply.Status != IPStatus.Success)
{
Notifier.ShowMessage("Adresse IP du serveur MySQL (ou MariaDB) est injoignable.", "Serveur MySQL injoignable", "error", 3);
return false;
}
}
catch
{
Notifier.ShowMessage("Impossible d'établir un test sur l'adresse IP du serveur MySQL (ou MariaDB).", "Adresse IP non testable", "error", 3);
return false;
}
return true;
}
}
else
{
Notifier.ShowMessage("Adresse IP serveur MySQL (ou MariaDB) incorrecte.", "Format de l'adresse IP", "error", 3);
return false;
}
}
public static async Task<PingReply> Ping(string hostNameOrIPAddress, int ttl = 0)
{
var pinger = new Ping();
var options = new PingOptions(ttl, dontFragment: true);
return await pinger.SendTaskAsync(hostNameOrIPAddress, 0x1388, DefaultSendBuffer, options);
}
public Ping()
{
this.InitializeComponent();
this.DoUpdateForm = this.UpdateForm;
// Create a buffer of 32 bytes of data to be transmitted.
this.buffer = Encoding.ASCII.GetBytes(new String('.', 32));
// Jump though 50 routing nodes tops, and don't fragment the packet
this.packetOptions = new PingOptions(50, true);
this.InitializeGraph();
this.dataGridView1.SuspendLayout();
this.dataGridView1.Columns.Add("1", "Count");
this.dataGridView1.Columns.Add("2", "Status");
this.dataGridView1.Columns.Add("3", "Host name");
this.dataGridView1.Columns.Add("4", "Destination");
this.dataGridView1.Columns.Add("5", "Bytes");
this.dataGridView1.Columns.Add("6", "Time to live");
this.dataGridView1.Columns.Add("7", "Roundtrip time");
this.dataGridView1.Columns.Add("8", "Time");
this.dataGridView1.ResumeLayout(true);
}
private void frm_wait_Shown(object sender, EventArgs e)
{
frm_main frm = (frm_main)this.Owner;
address = frm.current_pos;
curr_pos = address;
//Ping POS
Ping png = new Ping();
PingOptions opt = new PingOptions();
opt.DontFragment = true;
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes (data);
int timeout = 800;
PingReply reply = png.Send(address, timeout, buffer, opt);
if (reply.Status == IPStatus.Success)
{
if (Directory.Exists(@"\\" + address + @"\POS\Command\"))
{
address = @"\\" + address + @"\POS\Command\req18";
using (File.Create(address)) { }
}
else
{
MessageBox.Show("Нету связи с POS терминалом или папка Command не доступна", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
}
else
{
MessageBox.Show("Нету связи с POS терминалом или папка Command не доступна", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
bg_worker.WorkerSupportsCancellation = true;
bg_worker.RunWorkerAsync();
}
static void PingServer()
{
using (StreamReader reader = new StreamReader("guiConfig.json"))
{
string serverJson = reader.ReadToEnd();
ServerModel serverModel = JsonConvert.DeserializeObject<ServerModel>(serverJson);
if (serverModel != null && serverModel.configs != null && serverModel.configs.Count > 0)
{
foreach (Server server in serverModel.configs)
{
string strIp = server.server;
Ping ping = new Ping();
PingOptions options = new PingOptions();
options.DontFragment = true;
//测试数据
string data = "test data abcabc";
byte[] buffer = Encoding.ASCII.GetBytes(data);
//设置超时时间
int timeout = 2000;
//调用同步 send 方法发送数据,将返回结果保存至PingReply实例
PingReply reply = ping.Send(strIp, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
Console.WriteLine(string.Format("{0}---delay: {1}ms", server.remarks, reply.RoundtripTime));
}
}
}
}
}
private void PingServer(string server)
{
string result = "Test failed!";
var pingSender = new Ping();
var options = new PingOptions();
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
const string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
const int timeout = 120;
try
{
var reply = pingSender.Send(server, timeout, buffer, options);
if (reply != null && reply.Status == IPStatus.Success)
{
result = String.Format("Address: {0}\n", reply.Address.ToString());
result += String.Format("RoundTrip time: {0}\n", reply.RoundtripTime);
result += String.Format("Buffer size: {0}\n", reply.Buffer.Length);
result += Environment.NewLine;
result += "Test successful!\n";
}
}
catch (Exception) { }
MessageBox.Show(result, "Test Result");
}
public PingReply Ping(string hostOrIp)
{
Ping pingSender = new Ping();
//Ping 选项设置
PingOptions options = new PingOptions();
options.DontFragment = true;
//测试数据
string data = "test data abcabc";
byte[] buffer = Encoding.ASCII.GetBytes(data);
//设置超时时间
int timeout = 1200;
//调用同步 send 方法发送数据,将返回结果保存至PingReply实例
var reply = pingSender.Send(hostOrIp, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
return reply;
/*lst_PingResult.Items.Add("答复的主机地址：" + reply.Address.ToString());
lst_PingResult.Items.Add("往返时间：" + reply.RoundtripTime);
lst_PingResult.Items.Add("生存时间（TTL）：" + reply.Options.Ttl);
lst_PingResult.Items.Add("是否控制数据包的分段：" + reply.Options.DontFragment);
lst_PingResult.Items.Add("缓冲区大小：" + reply.Buffer.Length); */
}
else
throw new ApplicationException("Can't find the arrive at target " + hostOrIp.ToString());
}
private async void InternalSendAsync(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
AsyncOperation asyncOp = _asyncOp;
SendOrPostCallback callback = _onPingCompletedDelegate;
PingReply pr = null;
Exception pingException = null;
try
{
if (RawSocketPermissions.CanUseRawSockets())
{
pr = await SendIcmpEchoRequestOverRawSocket(address, buffer, timeout, options).ConfigureAwait(false);
}
else
{
pr = await SendWithPingUtility(address, buffer, timeout, options).ConfigureAwait(false);
}
}
catch (Exception e)
{
pingException = e;
}
// At this point, either PR has a real PingReply in it, or pingException has an Exception in it.
var ea = new PingCompletedEventArgs(
pr,
pingException,
false,
asyncOp.UserSuppliedState);
Finish();
asyncOp.PostOperationCompleted(callback, ea);
}
/* Ping an entered address */
public void PingAddress(string addr)
{
List<IPStatus> replies = new List<IPStatus>();
int count = 0;
// send 4 pings
while (count < 4)
{
// used to construct a 32 byte message
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
// intalize the ping object with ttl and no fragment options
PingOptions PingSettings = new PingOptions(53, true);
Ping Pinger = new Ping();
// send the ping
PingReply Reply = Pinger.Send(addr, timeout, buffer, PingSettings);
replies.Add(Reply.Status);
++count;
}
// tracks the ammount of successful replies
for (int i = 0; i < replies.Count; i++)
if (replies[i] == IPStatus.Success)
scount++;
}
public static bool PingIpOrDomainName(string strIpOrDname) {
try
{
Ping objPingSender = new Ping();
PingOptions objPinOptions = new PingOptions();
objPinOptions.DontFragment = true;
string data = "";
byte[] buffer = Encoding.UTF8.GetBytes(data);
int intTimeout = 120;
PingReply objRPinReply = objPingSender.Send(strIpOrDname, intTimeout, buffer, objPinOptions);
string strInfo = objRPinReply.Status.ToString();
if (strInfo == "Success")
{
return true;
}
else
{
return false;
}
}
catch (Exception)
{
return false;
}
}
public void launchPing(string IPAddress, string Hostname)
{
Ping newPing = new Ping();
PingOptions options = new PingOptions();
string data = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
bool shouldLoop = true;
while (shouldLoop == true)
{
PingReply reply = newPing.Send(IPAddress, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
Console.Title = Hostname;
Console.WriteLine("Reply from Address: {0} with a round trip time of {1}ms", IPAddress, reply.RoundtripTime.ToString());
System.Threading.Thread.Sleep(1000);
}
else
{
Console.WriteLine("Destination host unreachable or is not responding.");
System.Threading.Thread.Sleep(1000);
}
}
}
public static string[] ping(string host)
{
try
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
// Use the default Ttl value which is 128, e
// but change the fragmentation behavior.
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
PingReply reply = pingSender.Send(host, timeout, buffer, options);
string[] ping = new string[2];
if (reply.Status == IPStatus.Success)
{
ping[0] = reply.RoundtripTime.ToString();
ping[1] = reply.Options.Ttl.ToString();
}
else { ping[0] = "Error"; }
return ping;
}
catch
{
string[] err = new string[1];
err[0] = "Error\n Possibly you entered a malformed IP or domain.";
return err;
}
}
public static void Trace(IPAddress destination, Func<IPAddress, TracertNode, bool> callback)
{
if (destination == null)
{
throw new ArgumentNullException("destination");
}
else
{
if (callback == null)
{
throw new ArgumentNullException("callback");
}
else
{
var syncroot = new object();
var buffer = new byte[INT_BufferSize];
var options = new PingOptions(1, true);
var ping = new Ping();
ping.PingCompleted += (sender, e) =>
{
var address = e.Reply.Address;
var status = e.Reply.Status;
back:
var done = !callback.Invoke(destination, new TracertNode(address, status, e.Reply.Options.Ttl)) || address.Equals(destination);
if (done)
{
try
{
if (ping != null)
{
ping.Dispose();
}
}
finally
{
ping = null;
}
}
else
{
lock (syncroot)
{
if (ping == null)
{
address = destination;
status = IPStatus.Unknown;
goto back;
}
else
{
options.Ttl++;
ping.SendAsync(destination, INT_TimeoutMilliseconds, buffer, options, null);
}
}
}
};
ping.SendAsync(destination, INT_TimeoutMilliseconds, buffer, options, null);
}
}
}
/// <summary>
/// Ping network address
/// </summary>
/// <param name="address">IP Address or Hostname</param>
/// <returns></returns>
public static bool SendPing(string address, int tries)
{
int tries_count = 0;
Ping pingSender = new Ping ();
PingOptions options = new PingOptions ();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes (data);
int timeout = 120;
while (tries_count < tries)
{
PingReply reply = pingSender.Send(address, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
return true;
tries_count++;
}
return false;
}
public static bool Online(int retryTime)
{
Ping ping = new Ping();
PingOptions options = new PingOptions();
options.DontFragment = true;
PingReply reply;
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(string.Empty);
int index = 0;
while (index < retryTime)
{
try
{
reply = ping.Send("www.baidu.com", 5000, buffer, options);
if (reply.Status.Equals(IPStatus.Success))
return true;
}
catch
{
}
index++;
}
return false;
}
public static PingStatus Ping(string deviceName, PingerOptions options)
{
Ping pinger = new Ping();
PingOptions pingOptions = new PingOptions() { DontFragment = options.DontFragment };
// Create a buffer of 32 bytes of data to be transmitted.
byte a = Encoding.ASCII.GetBytes("a")[0];
byte[] buffer = new byte[options.PayloadSize]; // Encoding.ASCII.GetBytes(data);
for (int i = 0; i < options.PayloadSize; i++)
{
buffer[i] = a;
}
try
{
PingReply reply = pinger.Send(deviceName, options.Timeout, buffer, pingOptions);
if (reply.Status == IPStatus.Success)
{
//Ping was successful
return new PingStatus(true, (int)reply.Status, reply.RoundtripTime);
}
//Ping failed
return new PingStatus(false, (int)reply.Status, reply.RoundtripTime);
}
catch (Exception)
{
return new PingStatus(false, 99999, 99999);
}
}
public static bool TestConnection(string smtpServerAddress, int port)
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
options.DontFragment = true;
PingReply reply = null;
try
{
reply = pingSender.Send(smtpServerAddress, 12000, Encoding.ASCII.GetBytes("SHIT"), options);
}
catch (System.Net.NetworkInformation.PingException)
{
return false;
}
if (reply.Status == IPStatus.Success)
{
IPHostEntry hostEntry = Dns.GetHostEntry(smtpServerAddress);
IPEndPoint endPoint = new IPEndPoint(hostEntry.AddressList[0], port);
using (Socket tcpSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
{
tcpSocket.Connect(endPoint);
if (!CheckResponse(tcpSocket, 220))
return false;
SendData(tcpSocket, string.Format("HELO {0}\r\n", Dns.GetHostName()));
if (!CheckResponse(tcpSocket, 250))
return false;
return true;
}
}
else
return false;
}
public string TargetFound(string target)
{
try
{
Ping pingSender = new Ping();
PingOptions options = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
options.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
PingReply reply = pingSender.Send(target, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
return "targetfound";
}
else { return "targetnotfound"; }
}
catch(Exception e)
{
string CaughtException = e.ToString();
return CaughtException.Substring(0, CaughtException.IndexOf(Environment.NewLine));
}
}
public static bool CheckServerConnectivity(string ipAddress)
{
bool connectionExists = false;
string status = "";
try
{
System.Net.NetworkInformation.Ping pingSender = new System.Net.NetworkInformation.Ping();
System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions();
options.DontFragment = true;
if (!string.IsNullOrEmpty(ipAddress))
{
System.Net.NetworkInformation.PingReply reply = pingSender.Send(ipAddress);
connectionExists = reply.Status == System.Net.NetworkInformation.IPStatus.Success ? true : false;
}
}
catch (PingException ex)
{
status = ex.Message.ToString();
}
catch (AggregateException ex)
{
foreach (Exception inner in ex.InnerExceptions)
{
status = inner.Message.ToString();
}
}
return(connectionExists);
}
public pingObj()
{
pingSender = new Ping();
options = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
options.DontFragment = true;
}
internal PingReply (IPAddress address, byte [] buffer, PingOptions options, long roundtripTime, IPStatus status)
{
this.address = address;
this.buffer = buffer;
this.options = options;
this.rtt = roundtripTime;
this.ipStatus = status;
}
/// <summary>
/// Sends a ping using IcmpSendEcho2Ex function in Iphlpapi.dll. Use this method when you need to specify a source
/// interface for a ping otherwise use .NET ping implementation.
/// </summary>
/// <param name="srcAddress">The IPv4 source address on which to issue the echo request.</param>
/// <param name="destAddress">The IPv4 destination of the echo request.</param>
/// <param name="timeout">The time, in milliseconds, to wait for replies.</param>
/// <param name="buffer">A buffer that contains data to send in the request.</param>
/// <param name="po">IP header options for the request.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="FormatException">When the destination address is no valid IpV4 address or not defining a specific IP.</exception>
public static PingReply SendPing(IPAddress srcAddress, IPAddress destAddress, int timeout = 5000, byte[] buffer = null, PingOptions po = null)
{
if (destAddress == null)
throw new ArgumentNullException("destAddress");
if (destAddress.AddressFamily != AddressFamily.InterNetwork || srcAddress.AddressFamily != AddressFamily.InterNetwork || destAddress.Equals(IPAddress.Any))
throw new FormatException();
//Defining p invoke arguments.
var source = srcAddress == null ? 0 : BitConverter.ToUInt32(srcAddress.GetAddressBytes(), 0);
var destination = BitConverter.ToUInt32(destAddress.GetAddressBytes(), 0);
var sendbuffer = buffer ?? new byte[] {};
var options = new Interop.Option
{
Ttl = (po == null ? (byte) 255 : (byte) po.Ttl),
Flags = (po == null ? (byte) 0 : po.DontFragment ? (byte) 0x02 : (byte) 0) //0x02
};
var fullReplyBufferSize = Interop.ReplyMarshalLength + sendbuffer.Length; //Size of Reply structure plus the transmitted buffer length.
var allocSpace = Marshal.AllocHGlobal(fullReplyBufferSize); // unmanaged allocation of reply size. TODO Maybe should be allocated on stack
try
{
DateTime start = DateTime.Now;
var nativeCode = Interop.IcmpSendEcho2Ex(
Interop.IcmpHandle, //_In_ HANDLE IcmpHandle,
default(IntPtr), //_In_opt_ HANDLE Event,
default(IntPtr), //_In_opt_ PIO_APC_ROUTINE ApcRoutine,
default(IntPtr), //_In_opt_ PVOID ApcContext
source, //_In_ IPAddr SourceAddress,
destination, //_In_ IPAddr DestinationAddress,
sendbuffer, //_In_ LPVOID RequestData,
(short) sendbuffer.Length, //_In_ WORD RequestSize,
ref options, //_In_opt_ PIP_OPTION_INFORMATION RequestOptions,
allocSpace, //_Out_ LPVOID ReplyBuffer,
fullReplyBufferSize, //_In_ DWORD ReplySize,
timeout //_In_ DWORD Timeout
);
TimeSpan duration = DateTime.Now - start;
var reply = (Interop.Reply) Marshal.PtrToStructure(allocSpace, typeof (Interop.Reply)); // Parse the beginning of reply memory to reply structure
byte[] replyBuffer = null;
if (sendbuffer.Length != 0)
{
replyBuffer = new byte[sendbuffer.Length];
Marshal.Copy(allocSpace + Interop.ReplyMarshalLength, replyBuffer, 0, sendbuffer.Length); //copy the rest of the reply memory to managed byte[]
}
if (nativeCode == 0) //Means that native method is faulted.
return new PingReply(nativeCode, reply.Status, new IPAddress(reply.Address), duration);
else
return new PingReply(nativeCode, reply.Status, new IPAddress(reply.Address), reply.RoundTripTime, replyBuffer);
}
finally
{
Marshal.FreeHGlobal(allocSpace); //free allocated space
}
}
public static List<Hop> traceRoute(string ipAddrOrHostname, GatewayIPAddressInformation gateway, int minHops, int maxHops = 50, int timeout = 5000, byte[] buffer = null)
{
PingOptions pingOpts = new PingOptions();
Stopwatch watch = new Stopwatch();
//pingOpts.Ttl = 1; // only allow one hop initially
// create default buffer to send if not specified
if (buffer == null)
buffer = new byte[32];
List<Hop> hops = new List<Hop>();
// Always do the first hop, so we can verify expected route is being used;
// and if no interface was specified, well, its cheap anyway, since this is inside our PC
if (doPing(0, hops, pingOpts, watch, ipAddrOrHostname, timeout, buffer))
{
// check it
if (gateway!=null)
{
if (!gateway.Address.ToString().Equals(hops[0].ip))
{
MessageBox.Show("WARNING: First hop" + hops[0].ip
+ " didn't match intended gateway " + gateway.Address.ToString() + "; try 'route print'.");
}
}
}
else
{
// stop
if (gateway != null)
{
MessageBox.Show("Gateway " + gateway.Address.ToString() + " down?");
}
else
{
MessageBox.Show(hops[0].ip);
}
return hops;
}
if (minHops > 0)
{
// prefill
for (int i = 1; i < minHops; i++)
{
hops.Add(new Hop(i, "Dummy entry", -1, false));
}
}
int start = Math.Max(minHops, 1);
for (int i = start; i < maxHops; i++)
{
if (!doPing(i, hops, pingOpts, watch, ipAddrOrHostname, timeout , buffer)) {
// stop
break;
}
}
return hops;
}
public bool PingTest(string strURL)
{
System.Net.NetworkInformation.Ping objPing = new System.Net.NetworkInformation.Ping();
System.Net.NetworkInformation.PingOptions objOptions = new System.Net.NetworkInformation.PingOptions();
objOptions.DontFragment = true;
try{
System.Net.NetworkInformation.PingReply objReply = objPing.Send(strURL, 4);
return(true);
}
catch (SystemException e)
{
return(false);
}
}
private static PingReply DoPing(string AddressToPing)
{
//we dont really care about the data
string data = "This is a ping test";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 1024;
System.Net.NetworkInformation.Ping sendPing = new System.Net.NetworkInformation.Ping();
System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions
{
DontFragment = true
};
System.Net.NetworkInformation.PingReply reply = sendPing.Send(AddressToPing, timeout, buffer, options);
return(reply);
}
public bool Ping(string ip)
{
System.Net.NetworkInformation.Ping p = new System.Net.NetworkInformation.Ping();
System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions();
options.DontFragment = true;
string data = "Test Data!";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 1000; // Timeout 时间，单位：毫秒
System.Net.NetworkInformation.PingReply reply = p.Send(ip, timeout, buffer, options);
if (reply.Status == System.Net.NetworkInformation.IPStatus.Success)
{
return(true);
}
else
{
return(false);
}
}
private static void pingThread()
{
while (true)
{
try
{
foreach (virtualUser User in _Users)
{
if (User.pingOK)
{
try
{
byte[] buffer = new byte[32];
System.Net.NetworkInformation.PingOptions pingOptions = new System.Net.NetworkInformation.PingOptions(128, true);
System.Net.NetworkInformation.Ping ping = new System.Net.NetworkInformation.Ping();
System.Net.NetworkInformation.PingReply pingReply = ping.Send(((IPEndPoint)User.uSocket.RemoteEndPoint).Address, 75, buffer, pingOptions);
if (pingReply != null)
{
switch (pingReply.Status)
{
case System.Net.NetworkInformation.IPStatus.Success:
User.Ping = pingReply.RoundtripTime;
break;
}
}
}
catch
{
}
User.pingOK = false;
User.send(new PACKET_PING(User));
}
}
}
catch { }
Thread.Sleep(2500);
}
}
/// <summary>
/// check the net
/// </summary>
/// <param name="ip"></param>
/// <returns></returns>
private bool Ping(string ip)
{
try
{
System.Net.NetworkInformation.Ping p = new System.Net.NetworkInformation.Ping();
System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions();
int timeout = 1000; // Timeout 时间，单位：毫秒
System.Net.NetworkInformation.PingReply reply = p.Send(ip, timeout);
if (reply.Status == System.Net.NetworkInformation.IPStatus.Success)
{
return(true);
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
private PingReply SendUnprivileged(IPAddress address, int timeout, byte [] buffer, PingOptions options)
{
#if MONO_FEATURE_PROCESS_START
DateTime sentTime = DateTime.UtcNow;
Process ping = new Process();
string args = BuildPingArgs(address, timeout, options);
long trip_time = 0;
ping.StartInfo.FileName = PingBinPath;
ping.StartInfo.Arguments = args;
ping.StartInfo.CreateNoWindow = true;
ping.StartInfo.UseShellExecute = false;
ping.StartInfo.RedirectStandardOutput = true;
ping.StartInfo.RedirectStandardError = true;
IPStatus status = IPStatus.Unknown;
try {
ping.Start();
#pragma warning disable 219
string stdout = ping.StandardOutput.ReadToEnd();
string stderr = ping.StandardError.ReadToEnd();
#pragma warning restore 219
trip_time = (long)(DateTime.UtcNow - sentTime).TotalMilliseconds;
if (!ping.WaitForExit(timeout) || (ping.HasExited && ping.ExitCode == 2))
{
status = IPStatus.TimedOut;
}
else if (ping.ExitCode == 0)
{
status = IPStatus.Success;
}
else if (ping.ExitCode == 1)
{
status = IPStatus.TtlExpired;
}
} catch {
} finally {
if (!ping.HasExited)
{
ping.Kill();
}
ping.Dispose();
}
return(new PingReply(address, buffer, options, trip_time, status));
#else
throw new PlatformNotSupportedException("Ping is not supported on this platform.");
#endif // MONO_FEATURE_PROCESS_START
}
public PingReply Send(string hostNameOrAddress, int timeout, byte [] buffer, PingOptions options)
{
IPAddress [] addresses = Dns.GetHostAddresses(hostNameOrAddress);
return(Send(addresses [0], timeout, buffer, options));
}
private async Task <PingReply> SendWithPingUtility(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
bool isIpv4 = address.AddressFamily == AddressFamily.InterNetwork;
string pingExecutable = isIpv4 ? UnixCommandLinePing.Ping4UtilityPath : UnixCommandLinePing.Ping6UtilityPath;
if (pingExecutable == null)
{
throw new PlatformNotSupportedException(SR.net_ping_utility_not_found);
}
string processArgs = UnixCommandLinePing.ConstructCommandLine(buffer.Length, address.ToString(), isIpv4);
ProcessStartInfo psi = new ProcessStartInfo(pingExecutable, processArgs);
psi.RedirectStandardOutput = true;
psi.RedirectStandardError = true;
Process p = new Process()
{
StartInfo = psi
};
var processCompletion = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
p.EnableRaisingEvents = true;
p.Exited += (s, e) => processCompletion.SetResult(true);
p.Start();
var cts = new CancellationTokenSource();
Task timeoutTask = Task.Delay(timeout, cts.Token);
Task finished = await Task.WhenAny(processCompletion.Task, timeoutTask).ConfigureAwait(false);
if (finished == timeoutTask && !p.HasExited)
{
// Try to kill the ping process if it didn't return. If it is already in the process of exiting, a Win32Exception will be thrown.
try
{
p.Kill();
}
catch (Win32Exception) { }
return(CreateTimedOutPingReply());
}
else
{
cts.Cancel();
if (p.ExitCode != 0)
{
// This means no reply was received, although transmission may have been successful.
return(CreateTimedOutPingReply());
}
try
{
string output = await p.StandardOutput.ReadToEndAsync().ConfigureAwait(false);
long rtt = UnixCommandLinePing.ParseRoundTripTime(output);
return(new PingReply(
address,
null, // Ping utility cannot accomodate these, return null to indicate they were ignored.
IPStatus.Success,
rtt,
Array.Empty <byte>())); // Ping utility doesn't deliver this info.
}
catch (Exception)
{
// If the standard output cannot be successfully parsed, throw a generic PingException.
throw new PingException(SR.net_ping);
}
}
}
private async Task <PingReply> SendIcmpEchoRequestOverRawSocket(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
EndPoint endPoint = new IPEndPoint(address, 0);
bool isIpv4 = address.AddressFamily == AddressFamily.InterNetwork;
ProtocolType protocolType = isIpv4 ? ProtocolType.Icmp : ProtocolType.IcmpV6;
// Use the current thread's ID as the identifier.
ushort identifier = (ushort)Environment.CurrentManagedThreadId;
IcmpHeader header = new IcmpHeader()
{
Type = isIpv4 ? (byte)IcmpV4MessageType.EchoRequest : (byte)IcmpV6MessageType.EchoRequest,
Code = 0,
HeaderChecksum = 0,
Identifier = identifier,
SequenceNumber = 0,
};
byte[] sendBuffer = CreateSendMessageBuffer(header, buffer);
using (Socket socket = new Socket(address.AddressFamily, SocketType.Raw, protocolType))
{
socket.ReceiveTimeout = timeout;
socket.SendTimeout = timeout;
// Setting Socket.DontFragment and .Ttl is not supported on Unix, so ignore the PingOptions parameter.
int ipHeaderLength = isIpv4 ? IpHeaderLengthInBytes : 0;
await socket.SendToAsync(new ArraySegment <byte>(sendBuffer), SocketFlags.None, endPoint).ConfigureAwait(false);
byte[] receiveBuffer = new byte[ipHeaderLength + IcmpHeaderLengthInBytes + buffer.Length];
long elapsed;
Stopwatch sw = Stopwatch.StartNew();
// Read from the socket in a loop. We may receive messages that are not echo replies, or that are not in response
// to the echo request we just sent. We need to filter such messages out, and continue reading until our timeout.
// For example, when pinging the local host, we need to filter out our own echo requests that the socket reads.
while ((elapsed = sw.ElapsedMilliseconds) < timeout)
{
Task <SocketReceiveFromResult> receiveTask = socket.ReceiveFromAsync(
new ArraySegment <byte>(receiveBuffer),
SocketFlags.None,
endPoint);
var cts = new CancellationTokenSource();
Task finished = await Task.WhenAny(receiveTask, Task.Delay(timeout - (int)elapsed, cts.Token)).ConfigureAwait(false);
cts.Cancel();
if (finished != receiveTask)
{
sw.Stop();
return(CreateTimedOutPingReply());
}
SocketReceiveFromResult receiveResult = receiveTask.GetAwaiter().GetResult();
int bytesReceived = receiveResult.ReceivedBytes;
if (bytesReceived - ipHeaderLength < IcmpHeaderLengthInBytes)
{
continue; // Not enough bytes to reconstruct IP header + ICMP header.
}
byte type, code;
unsafe
{
fixed(byte *bytesPtr = receiveBuffer)
{
int icmpHeaderOffset = ipHeaderLength;
IcmpHeader receivedHeader = *((IcmpHeader *)(bytesPtr + icmpHeaderOffset)); // Skip IP header.
type = receivedHeader.Type;
code = receivedHeader.Code;
if (identifier != receivedHeader.Identifier ||
type == (byte)IcmpV4MessageType.EchoRequest ||
type == (byte)IcmpV6MessageType.EchoRequest) // Echo Request, ignore
{
continue;
}
}
}
sw.Stop();
long roundTripTime = sw.ElapsedMilliseconds;
int dataOffset = ipHeaderLength + IcmpHeaderLengthInBytes;
// We want to return a buffer with the actual data we sent out, not including the header data.
byte[] dataBuffer = new byte[bytesReceived - dataOffset];
Array.Copy(receiveBuffer, dataOffset, dataBuffer, 0, dataBuffer.Length);
IPStatus status = isIpv4
? IcmpV4MessageConstants.MapV4TypeToIPStatus(type, code)
: IcmpV6MessageConstants.MapV6TypeToIPStatus(type, code);
return(new PingReply(address, options, status, roundTripTime, dataBuffer));
}
// We have exceeded our timeout duration, and no reply has been received.
sw.Stop();
return(CreateTimedOutPingReply());
}
}
private async Task <PingReply> SendPingAsyncCore(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
try
{
Task <PingReply> t = RawSocketPermissions.CanUseRawSockets() ?
SendIcmpEchoRequestOverRawSocket(address, buffer, timeout, options) :
SendWithPingUtility(address, buffer, timeout, options);
return(await t.ConfigureAwait(false));
}
finally
{
Finish();
}
}
private SocketConfig GetSocketConfig(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
SocketConfig config = new SocketConfig();
config.EndPoint = new IPEndPoint(address, 0);
config.Timeout = timeout;
config.Options = options;
config.IsIpv4 = address.AddressFamily == AddressFamily.InterNetwork;
config.ProtocolType = config.IsIpv4 ? ProtocolType.Icmp : ProtocolType.IcmpV6;
// Use a random value as the identifier. This doesn't need to be perfectly random
// or very unpredictable, rather just good enough to avoid unexpected conflicts.
Random rand = t_idGenerator ?? (t_idGenerator = new Random());
config.Identifier = (ushort)rand.Next((int)ushort.MaxValue + 1);
IcmpHeader header = new IcmpHeader()
{
Type = config.IsIpv4 ? (byte)IcmpV4MessageType.EchoRequest : (byte)IcmpV6MessageType.EchoRequest,
Code = 0,
HeaderChecksum = 0,
Identifier = config.Identifier,
SequenceNumber = 0,
};
config.SendBuffer = CreateSendMessageBuffer(header, buffer);
return(config);
}
/// <summary>
/// 尝试用指定的数据缓冲区以异步方式将 Internet 控制消息协议 (ICMP) 回显消息发送到具有指定的 System.Net.IPAddress
/// 的计算机，并从该计算机接收对应的 ICMP 回显回复消息。此重载允许您指定操作的超时值，并控制 ICMP 回显消息数据包的碎片和生存时间值。
/// </summary>
/// <param name="address">标识 ICMP 回送消息目标计算机的 System.Net.IPAddress。</param>
/// <param name="times">Ping命令发送次数。</param>
/// <param name="timeout">一个 System.Byte 数组，它包含要与 ICMP 回送消息一起发送并在 ICMP 回送应答消息中返回的数据。该数组包含的字节数不能超过 65,500个字节。</param>
/// <param name="buffer">一个 System.Byte 数组，它包含要与 ICMP 回送消息一起发送并在 ICMP 回送应答消息中返回的数据。该数组包含的字节数不能超过 65,500个字节</param>
/// <param name="options">一个 System.Net.NetworkInformation.PingOptions 对象，用于控制 ICMP 回显消息数据包的碎片和生存时间值。</param>
/// <param name="userToken">一个对象，此对象将被传递给异步操作完成后所调用的方法。</param>
public void SendAsync(IPAddress address, Int32 times, Int32 timeout, Byte[] buffer, PingOptions options, Object userToken)
{
SendAsync(address.ToString(), times, timeout, buffer, options, userToken);
}
public void SendAsync(string hostNameOrAddress, int timeout, byte [] buffer, PingOptions options, object userToken)
{
IPAddress address = Dns.GetHostEntry(hostNameOrAddress).AddressList [0];
SendAsync(address, timeout, buffer, options, userToken);
}
private PingReply SendPrivileged(IPAddress address, int timeout, byte [] buffer, PingOptions options)
{
IPEndPoint target = new IPEndPoint(address, 0);
IPEndPoint client = new IPEndPoint(GetNonLoopbackIP(), 0);
// FIXME: support IPv6
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Icmp)) {
if (options != null)
{
s.DontFragment = options.DontFragment;
s.Ttl = (short)options.Ttl;
}
s.SendTimeout = timeout;
s.ReceiveTimeout = timeout;
// not sure why Identifier = 0 is unacceptable ...
IcmpMessage send = new IcmpMessage(8, 0, identifier, 0, buffer);
byte [] bytes = send.GetBytes();
s.SendBufferSize = bytes.Length;
s.SendTo(bytes, bytes.Length, SocketFlags.None, target);
DateTime sentTime = DateTime.Now;
// receive
bytes = new byte [100];
do
{
EndPoint endpoint = client;
SocketError error = 0;
int rc = s.ReceiveFrom(bytes, 0, 100, SocketFlags.None,
ref endpoint, out error);
if (error != SocketError.Success)
{
if (error == SocketError.TimedOut)
{
return(new PingReply(null, new byte [0], options, 0, IPStatus.TimedOut));
}
throw new NotSupportedException(String.Format("Unexpected socket error during ping request: {0}", error));
}
long rtt = (long)(DateTime.Now - sentTime).TotalMilliseconds;
int headerLength = (bytes [0] & 0xF) << 2;
int bodyLength = rc - headerLength;
// Ping reply to different request. discard it.
if (!((IPEndPoint)endpoint).Address.Equals(target.Address))
{
long t = timeout - rtt;
if (t <= 0)
{
return(new PingReply(null, new byte [0], options, 0, IPStatus.TimedOut));
}
s.ReceiveTimeout = (int)t;
continue;
}
IcmpMessage recv = new IcmpMessage(bytes, headerLength, bodyLength);
/* discard ping reply to different request or echo requests if running on same host. */
if (recv.Identifier != identifier || recv.Type == 8)
{
long t = timeout - rtt;
if (t <= 0)
{
return(new PingReply(null, new byte [0], options, 0, IPStatus.TimedOut));
}
s.ReceiveTimeout = (int)t;
continue;
}
return(new PingReply(address, recv.Data, options, rtt, recv.IPStatus));
} while (true);
}
}
private PingReply SendUnprivileged(IPAddress address, int timeout, byte [] buffer, PingOptions options)
{
DateTime sentTime = DateTime.Now;
Process ping = new Process();
string args = BuildPingArgs(address, timeout, options);
long trip_time = 0;
ping.StartInfo.FileName = PingBinPath;
ping.StartInfo.Arguments = args;
ping.StartInfo.CreateNoWindow = true;
ping.StartInfo.UseShellExecute = false;
ping.StartInfo.RedirectStandardOutput = true;
ping.StartInfo.RedirectStandardError = true;
try
{
ping.Start();
#pragma warning disable 219
string stdout = ping.StandardOutput.ReadToEnd();
string stderr = ping.StandardError.ReadToEnd();
#pragma warning restore 219
trip_time = (long)(DateTime.Now - sentTime).TotalMilliseconds;
if (!ping.WaitForExit(timeout) || (ping.HasExited && ping.ExitCode == 2))
{
return(new PingReply(address, buffer, options, trip_time, IPStatus.TimedOut));
}
if (ping.ExitCode == 1)
{
return(new PingReply(address, buffer, options, trip_time, IPStatus.TtlExpired));
}
}
catch (Exception)
{
return(new PingReply(address, buffer, options, trip_time, IPStatus.Unknown));
}
finally
{
if (ping != null)
{
if (!ping.HasExited)
{
ping.Kill();
}
ping.Dispose();
}
}
return(new PingReply(address, buffer, options, trip_time, IPStatus.Success));
}
public Task <PingReply> SendPingAsync(string hostNameOrAddress, int timeout, byte[] buffer, PingOptions options)
{
if (string.IsNullOrEmpty(hostNameOrAddress))
{
throw new ArgumentNullException(nameof(hostNameOrAddress));
}
IPAddress address;
if (IPAddress.TryParse(hostNameOrAddress, out address))
{
return(SendPingAsync(address, timeout, buffer, options));
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (buffer.Length > MaxBufferSize)
{
throw new ArgumentException(SR.net_invalidPingBufferSize, nameof(buffer));
}
if (timeout < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeout));
}
CheckStart();
return(GetAddressAndSendAsync(hostNameOrAddress, timeout, buffer, options));
}
private async Task <PingReply> SendIcmpEchoRequestOverRawSocketAsync(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
SocketConfig socketConfig = GetSocketConfig(address, buffer, timeout, options);
using (Socket socket = GetRawSocket(socketConfig))
{
int ipHeaderLength = socketConfig.IsIpv4 ? MinIpHeaderLengthInBytes : 0;
await socket.SendToAsync(
new ArraySegment <byte>(socketConfig.SendBuffer),
SocketFlags.None, socketConfig.EndPoint)
.ConfigureAwait(false);
byte[] receiveBuffer = new byte[MaxIpHeaderLengthInBytes + IcmpHeaderLengthInBytes + buffer.Length];
long elapsed;
Stopwatch sw = Stopwatch.StartNew();
// Read from the socket in a loop. We may receive messages that are not echo replies, or that are not in response
// to the echo request we just sent. We need to filter such messages out, and continue reading until our timeout.
// For example, when pinging the local host, we need to filter out our own echo requests that the socket reads.
while ((elapsed = sw.ElapsedMilliseconds) < timeout)
{
Task <SocketReceiveFromResult> receiveTask = socket.ReceiveFromAsync(
new ArraySegment <byte>(receiveBuffer),
SocketFlags.None,
socketConfig.EndPoint);
var cts = new CancellationTokenSource();
Task finished = await Task.WhenAny(receiveTask, Task.Delay(timeout - (int)elapsed, cts.Token)).ConfigureAwait(false);
cts.Cancel();
if (finished != receiveTask)
{
return(CreateTimedOutPingReply());
}
SocketReceiveFromResult receiveResult = receiveTask.GetAwaiter().GetResult();
int bytesReceived = receiveResult.ReceivedBytes;
if (bytesReceived - ipHeaderLength < IcmpHeaderLengthInBytes)
{
continue; // Not enough bytes to reconstruct IP header + ICMP header.
}
if (TryGetPingReply(socketConfig, receiveBuffer, bytesReceived, sw, ref ipHeaderLength, out PingReply reply))
{
return(reply);
}
}
// We have exceeded our timeout duration, and no reply has been received.
return(CreateTimedOutPingReply());
}
}
private PingReply SendPingCore(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
try
{
PingReply reply = RawSocketPermissions.CanUseRawSockets(address.AddressFamily) ?
SendIcmpEchoRequestOverRawSocket(address, buffer, timeout, options) :
SendWithPingUtility(address, buffer, timeout, options);
return(reply);
}
finally
{
Finish();
}
}
private PingReply SendWithPingUtility(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
using (Process p = GetPingProcess(address, buffer, options))
{
p.Start();
if (!p.WaitForExit(timeout) || p.ExitCode == 1 || p.ExitCode == 2)
{
return(CreateTimedOutPingReply());
}
try
{
string output = p.StandardOutput.ReadToEnd();
return(ParsePingUtilityOutput(address, output));
}
catch (Exception)
{
// If the standard output cannot be successfully parsed, throw a generic PingException.
throw new PingException(SR.net_ping);
}
}
}
public Task <PingReply> SendPingAsync(IPAddress address, int timeout, byte [] buffer, PingOptions options)
{
if ((worker != null) || (cts != null))
{
throw new InvalidOperationException("Another SendAsync operation is in progress");
}
cts = new CancellationTokenSource();
var task = Task <PingReply> .Factory.StartNew(
() => Send (address, timeout, buffer, options), cts.Token);
task.ContinueWith((t) => {
if (t.IsCanceled)
{
OnPingCompleted(new PingCompletedEventArgs(null, true, null, null));
}
else if (t.IsFaulted)
{
OnPingCompleted(new PingCompletedEventArgs(t.Exception, false, null, null));
}
else
{
OnPingCompleted(new PingCompletedEventArgs(null, false, null, t.Result));
}
});
return(task);
}
public Task <PingReply> SendPingAsync(string hostNameOrAddress, int timeout, byte [] buffer, PingOptions options)
{
IPAddress address = Dns.GetHostEntry(hostNameOrAddress).AddressList [0];
return(SendPingAsync(address, timeout, buffer, options));
}
private async Task <PingReply> GetAddressAndSendAsync(string hostNameOrAddress, int timeout, byte[] buffer, PingOptions options)
{
bool requiresFinish = true;
try
{
IPAddress[] addresses = await Dns.GetHostAddressesAsync(hostNameOrAddress).ConfigureAwait(false);
Task <PingReply> pingReplyTask = SendPingAsyncCore(addresses[0], buffer, timeout, options);
requiresFinish = false;
return(await pingReplyTask.ConfigureAwait(false));
}
catch (Exception e)
{
// SendPingAsyncCore will call Finish before completing the Task. If SendPingAsyncCore isn't invoked
// because an exception is thrown first, or if it throws out an exception synchronously, then
// we need to invoke Finish; otherwise, it has the responsibility to invoke Finish.
if (requiresFinish)
{
Finish();
}
throw new PingException(SR.net_ping, e);
}
}
private PingReply SendIcmpEchoRequestOverRawSocket(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
SocketConfig socketConfig = GetSocketConfig(address, buffer, timeout, options);
using (Socket socket = GetRawSocket(socketConfig))
{
int ipHeaderLength = socketConfig.IsIpv4 ? MinIpHeaderLengthInBytes : 0;
try
{
socket.SendTo(socketConfig.SendBuffer, SocketFlags.None, socketConfig.EndPoint);
}
catch (SocketException ex) when(ex.SocketErrorCode == SocketError.TimedOut)
{
return(CreateTimedOutPingReply());
}
byte[] receiveBuffer = new byte[MaxIpHeaderLengthInBytes + IcmpHeaderLengthInBytes + buffer.Length];
long elapsed;
Stopwatch sw = Stopwatch.StartNew();
// Read from the socket in a loop. We may receive messages that are not echo replies, or that are not in response
// to the echo request we just sent. We need to filter such messages out, and continue reading until our timeout.
// For example, when pinging the local host, we need to filter out our own echo requests that the socket reads.
while ((elapsed = sw.ElapsedMilliseconds) < timeout)
{
int bytesReceived;
try
{
bytesReceived = socket.ReceiveFrom(receiveBuffer, SocketFlags.None, ref socketConfig.EndPoint);
}
catch (SocketException ex) when(ex.SocketErrorCode == SocketError.TimedOut)
{
return(CreateTimedOutPingReply());
}
if (bytesReceived - ipHeaderLength < IcmpHeaderLengthInBytes)
{
continue; // Not enough bytes to reconstruct IP header + ICMP header.
}
if (TryGetPingReply(socketConfig, receiveBuffer, bytesReceived, sw, ref ipHeaderLength, out PingReply reply))
{
return(reply);
}
}
// We have exceeded our timeout duration, and no reply has been received.
return(CreateTimedOutPingReply());
}
}
public Task <PingReply> SendPingAsync(IPAddress address, int timeout, byte[] buffer, PingOptions options)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (buffer.Length > MaxBufferSize)
{
throw new ArgumentException(SR.net_invalidPingBufferSize, nameof(buffer));
}
if (timeout < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeout));
}
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
// Check if address family is installed.
TestIsIpSupported(address);
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
{
throw new ArgumentException(SR.net_invalid_ip_addr, nameof(address));
}
// Need to snapshot the address here, so we're sure that it's not changed between now
// and the operation, and to be sure that IPAddress.ToString() is called and not some override.
IPAddress addressSnapshot = (address.AddressFamily == AddressFamily.InterNetwork) ?
new IPAddress(address.GetAddressBytes()) :
new IPAddress(address.GetAddressBytes(), address.ScopeId);
CheckStart();
try
{
return(SendPingAsyncCore(addressSnapshot, buffer, timeout, options));
}
catch (Exception e)
{
Finish();
return(Task.FromException <PingReply>(new PingException(SR.net_ping, e)));
}
}
public void SendAsync(IPAddress ipAddress, PingOptions pingOptions, CancellationToken cancellationToken)
{
Task.Run(() =>
{
var hostname = pingOptions.Hostname;
// Try to resolve PTR
if (string.IsNullOrEmpty(hostname))
{
try
{
Task.Run(() =>
{
hostname = Dns.GetHostEntryAsync(ipAddress).Result.HostName;
}, cancellationToken);
}
catch (SocketException) { }
}
var pingTotal = 0;
var errorCount = 0;
var options = new System.Net.NetworkInformation.PingOptions
{
Ttl = pingOptions.TTL,
DontFragment = pingOptions.DontFragment
};
using (var ping = new System.Net.NetworkInformation.Ping())
{
do
{
try
{
// Get timestamp
var timestamp = DateTime.Now;
// Send ping
var pingReply = ping.Send(ipAddress, pingOptions.Timeout, pingOptions.Buffer, options);
// Reset the error count (if no exception was thrown)
errorCount = 0;
if (pingReply == null || pingReply.Status != IPStatus.Success)
{
if (pingReply != null && pingReply.Address == null)
{
OnPingReceived(new PingReceivedArgs(timestamp, ipAddress, hostname, pingReply.Status));
}
else if (pingReply != null)
{
OnPingReceived(new PingReceivedArgs(timestamp, pingReply.Address, hostname, pingReply.Status));
}
}
else
{
if (ipAddress.AddressFamily == AddressFamily.InterNetwork)
{
OnPingReceived(new PingReceivedArgs(timestamp, pingReply.Address, hostname,
pingReply.Buffer.Length, pingReply.RoundtripTime, pingReply.Options.Ttl, pingReply.Status));
}
else
{
OnPingReceived(new PingReceivedArgs(timestamp, pingReply.Address, hostname,
pingReply.Buffer.Length, pingReply.RoundtripTime, pingReply.Status));
}
}
}
catch (PingException ex)
{
errorCount++;
if (errorCount == pingOptions.ExceptionCancelCount)
{
OnPingException(new PingExceptionArgs(ex.Message, ex.InnerException));
break;
}
}
pingTotal++;
// If ping is canceled... dont wait for example 5 seconds
for (var i = 0; i < pingOptions.WaitTime; i += 100)
{
Thread.Sleep(100);
if (cancellationToken.IsCancellationRequested)
{
break;
}
}
} while ((pingOptions.Attempts == 0 || pingTotal < pingOptions.Attempts) && !cancellationToken.IsCancellationRequested);
}
if (cancellationToken.IsCancellationRequested)
{
OnUserHasCanceled();
}
else
{
OnPingCompleted();
}
}, cancellationToken);
}
// Any exceptions that escape synchronously will be caught by the caller and wrapped in a PingException.
// We do not need to or want to capture such exceptions into the returned task.
private Task <PingReply> SendPingAsyncCore(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
var tcs = new TaskCompletionSource <PingReply>();
_taskCompletionSource = tcs;
_ipv6 = (address.AddressFamily == AddressFamily.InterNetworkV6);
_sendSize = buffer.Length;
// Get and cache correct handle.
if (!_ipv6 && _handlePingV4 == null)
{
_handlePingV4 = Interop.IpHlpApi.IcmpCreateFile();
if (_handlePingV4.IsInvalid)
{
_handlePingV4 = null;
throw new Win32Exception(); // Gets last error.
}
}
else if (_ipv6 && _handlePingV6 == null)
{
_handlePingV6 = Interop.IpHlpApi.Icmp6CreateFile();
if (_handlePingV6.IsInvalid)
{
_handlePingV6 = null;
throw new Win32Exception(); // Gets last error.
}
}
var ipOptions = new Interop.IpHlpApi.IPOptions(options);
if (_replyBuffer == null)
{
_replyBuffer = SafeLocalAllocHandle.LocalAlloc(MaxUdpPacket);
}
// Queue the event.
int error;
try
{
if (_pingEvent == null)
{
_pingEvent = new ManualResetEvent(false);
}
else
{
_pingEvent.Reset();
}
_registeredWait = ThreadPool.RegisterWaitForSingleObject(_pingEvent, (state, _) => ((Ping)state).PingCallback(), this, -1, true);
SetUnmanagedStructures(buffer);
if (!_ipv6)
{
SafeWaitHandle pingEventSafeWaitHandle = _pingEvent.GetSafeWaitHandle();
error = (int)Interop.IpHlpApi.IcmpSendEcho2(
_handlePingV4,
pingEventSafeWaitHandle,
IntPtr.Zero,
IntPtr.Zero,
(uint)address.GetAddress(),
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout);
}
else
{
IPEndPoint ep = new IPEndPoint(address, 0);
Internals.SocketAddress remoteAddr = IPEndPointExtensions.Serialize(ep);
byte[] sourceAddr = new byte[28];
SafeWaitHandle pingEventSafeWaitHandle = _pingEvent.GetSafeWaitHandle();
error = (int)Interop.IpHlpApi.Icmp6SendEcho2(
_handlePingV6,
pingEventSafeWaitHandle,
IntPtr.Zero,
IntPtr.Zero,
sourceAddr,
remoteAddr.Buffer,
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout);
}
}
catch
{
UnregisterWaitHandle();
throw;
}
if (error == 0)
{
error = Marshal.GetLastWin32Error();
// Only skip Async IO Pending error value.
if (error != Interop.IpHlpApi.ERROR_IO_PENDING)
{
// Cleanup.
FreeUnmanagedStructures();
UnregisterWaitHandle();
throw new Win32Exception(error);
}
}
return(tcs.Task);
}
/// <summary>
/// 尝试用指定的数据缓冲区以异步方式将 Internet 控制消息协议 (ICMP) 回显消息发送到具有指定的 System.Net.IPAddress
/// 的计算机，并从该计算机接收对应的 ICMP 回显回复消息。此重载允许您指定操作的超时值，并控制 ICMP 回显消息数据包的碎片和生存时间值。
/// </summary>
/// <param name="hostNameOrAddress">一个 System.String，它标识作为 ICMP 回送消息目标的计算机。为此参数指定的值可以是主机名，也可以是以字符串形式表示的 IP 地址。</param>
/// <param name="times">Ping命令发送次数。</param>
/// <param name="timeout">一个 System.Byte 数组，它包含要与 ICMP 回送消息一起发送并在 ICMP 回送应答消息中返回的数据。该数组包含的字节数不能超过 65,500个字节。</param>
/// <param name="buffer">一个 System.Byte 数组，它包含要与 ICMP 回送消息一起发送并在 ICMP 回送应答消息中返回的数据。该数组包含的字节数不能超过 65,500个字节</param>
/// <param name="options">一个 System.Net.NetworkInformation.PingOptions 对象，用于控制 ICMP 回显消息数据包的碎片和生存时间值。</param>
/// <param name="userToken">一个对象，此对象将被传递给异步操作完成后所调用的方法。</param>
public void SendAsync(String hostNameOrAddress, Int32 times, Int32 timeout, Byte[] buffer, PingOptions options, Object userToken)
{
lock (this)
{
if (m_Pinging != false)
{
throw new InvalidOperationException("The call of SendAsync is underway.");
}
m_Times = times;
m_UserToken = userToken;
m_Replys.Clear();
m_Ping.SendAsync(hostNameOrAddress, timeout, buffer, options, userToken);
}
}
private async Task <PingReply> SendPingAsyncCore(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
try
{
Task <PingReply> t = RawSocketPermissions.CanUseRawSockets(address.AddressFamily) ?
SendIcmpEchoRequestOverRawSocketAsync(address, buffer, timeout, options) :
SendWithPingUtilityAsync(address, buffer, timeout, options);
PingReply reply = await t.ConfigureAwait(false);
if (_canceled)
{
throw new OperationCanceledException();
}
return(reply);
}
finally
{
Finish();
}
}
private async Task <PingReply> SendWithPingUtilityAsync(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
using (Process p = GetPingProcess(address, buffer, options))
{
var processCompletion = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
p.EnableRaisingEvents = true;
p.Exited += (s, e) => processCompletion.SetResult(true);
p.Start();
var cts = new CancellationTokenSource();
Task timeoutTask = Task.Delay(timeout, cts.Token);
Task finished = await Task.WhenAny(processCompletion.Task, timeoutTask).ConfigureAwait(false);
if (finished == timeoutTask && !p.HasExited)
{
// Try to kill the ping process if it didn't return. If it is already in the process of exiting,
// a Win32Exception will be thrown.
try
{
p.Kill();
}
catch (Win32Exception) { }
return(CreateTimedOutPingReply());
}
else
{
cts.Cancel();
if (p.ExitCode == 1 || p.ExitCode == 2)
{
// Throw timeout for known failure return codes from ping functions.
return(CreateTimedOutPingReply());
}
try
{
string output = await p.StandardOutput.ReadToEndAsync().ConfigureAwait(false);
return(ParsePingUtilityOutput(address, output));
}
catch (Exception)
{
// If the standard output cannot be successfully parsed, throw a generic PingException.
throw new PingException(SR.net_ping);
}
}
}
}