public PingCompletedEventArgs(PingResponse pingResponse, DateTime endDateTime)
 {
     this.pingResponse = pingResponse;
     this.endDateTime = endDateTime;
 }
        private PingResponse SendPackets(Socket socket, EndPoint client, EndPoint server, byte[] sendBuffer, int pingCount)
        {
            //Initialize PingResponse object
            PingResponse response = new PingResponse(pingCount);
            PingResponseType result = PingResponseType.Ok;

            byte[] receiveBuffer = new Byte[256];
            int byteCount = 0;
            int start = 0;
            int stop = 0;
            response.PacketsReceived = 0;
            response.PacketsSent = 0;

            response.ServerEndPoint = (IPEndPoint)server;
            response.ClientEndPoint = (IPEndPoint)client;

            try
            {
                OnPingStarted((IPEndPoint)server, IcmpPacket.ICMP_PACKET_SIZE);

                for (int i = 0; i < pingCount; i++)
                {
                    if (cancel)
                    {
                        response.PingResult = PingResponseType.Canceled;
                        break;
                    }

                    // Initialize the buffers. The receive buffer is the size of the
                    // ICMP header plus the IP header (20 bytes)
                    receiveBuffer = new Byte[256];
                    byteCount = 0;
                    response.PacketsSent++;

                    try
                    {
                        // Start timing
                        start = Environment.TickCount;

                        //send the Packet over the socket
                        byteCount = socket.SendTo(sendBuffer, IcmpPacket.ICMP_PACKET_SIZE, SocketFlags.None, server);

                        if (byteCount == SOCKET_ERROR)
                        {
                            result = PingResponseType.ConnectionError;
                            response.ResponseTimes[i] = Constants.InvalidInt;
                        }
                        else
                        {
                            //ReceiveFrom will block while waiting for data
                            byteCount = socket.ReceiveFrom(receiveBuffer, 256, SocketFlags.None, ref client);

                            // stop timing
                            stop = System.Environment.TickCount;

                            if (byteCount == SOCKET_ERROR)
                            {
                                result = PingResponseType.ConnectionError;
                                response.ResponseTimes[i] = Constants.InvalidInt;
                            }
                            else if ((stop - start) > pingTimeout)
                            {
                                result = PingResponseType.RequestTimedOut;
                                response.ResponseTimes[i] = Constants.InvalidInt;
                            }
                            else if (byteCount > 0)
                            {
                                //Record time
                                response.ResponseTimes[i] = stop - start;
                                response.PacketsReceived++;
                            }
                        }

                        OnPingResponse(((IPEndPoint)server).Address, result, response.ResponseTimes[i], byteCount, ref cancel);
                    }
                    catch (Exception ex)
                    {
                        OnPingError(PingResponseType.InternalError, ex.Message);
                    }
                }
            }
            finally
            {
                //close the socket
                socket.Close();

                OnPingCompleted(response);
            }

            response.PingResult = result;
            return response;
        }
        private void OnPingCompleted(PingResponse response)
        {
            PingCompletedEventHandler temp = PingCompleted;

            if (temp != null)
            {
                temp(this, new PingCompletedEventArgs(response, DateTime.Now));
            }
        }
        /// <summary>
        /// Attempts to ping a host.
        /// </summary>
        /// <param name="serverEndPoint">EndPoint to ping</param>
        /// <param name="pingCount">Ping count</param>
        /// <returns>Ping results</returns>
        public PingResponse PingHost(IPEndPoint serverEndPoint, int pingCount)
        {
            cancel = false;

            PingResponse response = new PingResponse();

            try
            {
                //Initialize a Socket of the Type ICMP
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Icmp);
                socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, this.pingTimeout);

                // Set the receiving endpoint to the client machine
                IPHostEntry clientHostEntry = Dns.GetHostByName(Dns.GetHostName());
                EndPoint clientEndPoint = (new IPEndPoint(clientHostEntry.AddressList[0], 0));

                //Create icmp packet
                IcmpPacket packet = new IcmpPacket();

                // Convert icmp packet to byte array to send over socket
                byte[] sendBuffer = packet.ToByteArray();
                if (sendBuffer == null)
                {
                    OnPingError(PingResponseType.InternalError, "Could not copy ICMP packet to byte array");

                    response.PingResult = PingResponseType.InternalError;
                    response.ErrorMessage = "Could not copy ICMP packet to byte array";
                }
                else
                {
                    response = SendPackets(socket, clientEndPoint, serverEndPoint, sendBuffer, pingCount);
                }
            }
            catch (Exception ex)
            {
                OnPingError(PingResponseType.InternalError, ex.Message);

                response.PingResult = PingResponseType.InternalError;
                response.ErrorMessage = ex.Message;
            }

            return response;
        }
        /// <summary>
        /// Attempts to ping a host.
        /// </summary>
        /// <param name="serverAddress">IPAddress to ping</param>
        /// <param name="pingCount">Ping count</param>
        /// <returns>Ping results</returns>
        public PingResponse PingHost(IPAddress serverAddress, int pingCount)
        {
            PingResponse response = null;

            try
            {
                // Convert the server IPAddress to an IPEndPoint
                response = PingHost(new IPEndPoint(serverAddress, 0), pingCount);
            }
            catch (Exception ex)
            {
                OnPingError(PingResponseType.InternalError, ex.Message);

                response = new PingResponse();
                response.PingResult = PingResponseType.InternalError;
                response.ErrorMessage = ex.Message;
            }

            return response;
        }
        /// <summary>
        /// Attempts to ping a host.
        /// </summary>
        /// <param name="hostname">Host to ping</param>
        /// <param name="pingCount">Ping count</param>
        /// <returns>Ping results</returns>
        public PingResponse PingHost(string hostname, int pingCount)
        {
            IPHostEntry host = NetworkUtilities.ResolveHost(hostname);

            if (host == null)
            {
                OnPingError(PingResponseType.CouldNotResolveHost, "Could not resolve the host '" + hostname + "'");

                PingResponse response = new PingResponse();
                response.PingResult = PingResponseType.CouldNotResolveHost;
                response.ErrorMessage = "Could not resolve the host '" + hostname + "'";

                return response;
            }
            else
            {
                return PingHost(new IPEndPoint(host.AddressList[0], 0), pingCount);
            }
        }