How to implement ping in golang

golang implements ping

Ping is a tool used to test network connections. It is used to test the connectivity of the computer network. The Ping command can test whether the target host is online, accessible, and the communication delay. This article will introduce how to implement the ping tool using the golang programming language.

1. What is Ping

Ping is an essential tool for programmers and system administrators to conduct network debugging and troubleshooting. Ping is the abbreviation of Packet Internet Groper, and its function is to test the connectivity of the network connection between two hosts. The Ping command is one of the most basic network services on the Internet. It checks the real-time and reliability of the connection by sending ICMP packets to the target host and measuring the response time.

2. How Ping works

The principle of Ping is to use the "echo request" command of the Internet Control Message Protocol (ICMP) to send a special data packet to the target host. After receiving this packet, an "echo response" packet will be automatically returned to the sender. In this way, the sender can calculate the response time and network delay of the target host by measuring the round-trip time of the packet.

3. Implementing ping

To implement ping, you need to complete the following three steps:

1. Construct ICMP data packets
2. Send ICMP data packets
3 .Parse the response information returned by the ICMP packet

1.Construct the ICMP packet

First, we need to construct an ICMP packet. According to the ICMP format, we can use the structures and functions provided by the "icmp" package that comes with the Go language to construct an ICMP data packet. icmp.Message and icmp.Echo specify the packet type and type-related data, and icmp.Marshal retrieves the ICMP data we constructed. We can define a PingMsg as follows:

type PingMsg struct{

icmpMessage icmp.Message
bytes []byte

}

func newEchoPingMessage(id, seq int) (*PingMsg, error){

bytes := make([]byte, 32)

//Fill ICMP packet content

for i, _ := range bytes {
    bytes[i] = 'a' + byte(i%26)
}
icmpMessage := icmp.Message{
    Type: ipv4.ICMPTypeEcho, // ICMP类型
    Code: 0, // ICMP代码，置为0
    Checksum: 0, // 校验和，暂时置为0
    Body: &icmp.Echo{
        ID: id,
        Seq: seq,
        Data: bytes,
    },
}

//Serialize ICMP packet

b, err := icmpMessage.Marshal(nil)
if err != nil {
    return nil, err
}
return &PingMsg{
    bytes: b,
    icmpMessage: icmpMessage,
}, nil

}

2. Send ICMP packet

Next, we need to use the Conn interface provided by the net package to send the constructed ICMP packet. We can use net.Dial("ip4:icmp", destination) to establish an ICMP connection, use Conn.Write(b []byte) to send data packets to the target host, and use the time.NewTicker function to control the sending time interval.

func ping(addr string) error{

conn, err := net.Dial("ip4:icmp", addr)
if err != nil {
    return err
}
defer conn.Close()
pingMsg, err := newEchoPingMessage(os.Getpid()&0xffff, 1)
if err != nil {
    return err
}
timeout := 5 * time.Second // 超时时间
ticker := time.NewTicker(time.Second) //设置1秒钟的时间间隔
defer ticker.Stop()
for {
    select {
    case <- ticker.C: // 每1秒钟发送一次ICMP数据包
        if _, err = conn.Write(pingMsg.bytes); err != nil {
            return err
        }
    case <- time.After(timeout): // 超时时间到了，抛出错误
        return errors.New("request timeout")
    }
}

}

3. Parse the response information returned by the ICMP packet

Finally, we need to read Get the returned ICMP packet and parse the host's response information. We also use the Conn interface provided by the net package to read the returned data packet, use icmp.ParseMessage to parse the data packet, and obtain the response information through icmp.Message.Body.(*icmp.EchoReply).

func receivePing(conn net.Conn) error{

for {
    b := make([]byte, 512)
    conn.SetReadDeadline(time.Now().Add(time.Second)) // 设置超时时间
    if n, err := conn.Read(b); err != nil {
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            continue
        }
        return err
    } else {
        recvMsg, err := icmp.ParseMessage(ipv4.ICMPTypeEchoReply, b[:n])
        if err != nil {
            return err
        }
        switch recvMsg.Type {
        case ipv4.ICMPTypeEchoReply:
            echoReply, _ := recvMsg.Body.(*icmp.EchoReply)
            log.Printf("ping %d bytes from %s: icmp_seq=%d time=%dms", len(echoReply.Data), conn.RemoteAddr().String(), echoReply.Seq, time.Since(time.Unix(0, echoReply.ArrivalTime().Nanoseconds())).Nanoseconds())
        default:
            log.Printf("unsupported ICMP message type %v (%v)", recvMsg.Type, recvMsg.Code)
        }
    }
}

}

4. Complete example

The complete code is as follows:

package main

import (

"errors"
"fmt"
"golang.org/x/net/icmp"
"golang.org/x/net/ipv4"
"log"
"net"
"os"
"time"

)

type PingMsg struct{

icmpMessage icmp.Message
bytes       []byte

}

func newEchoPingMessage(id, seq int) (*PingMsg, error){

bytes := make([]byte, 32)
for i, _ := range bytes {
    bytes[i] = 'a' + byte(i%26)
}
icmpMessage := icmp.Message{
    Type: ipv4.ICMPTypeEcho,
    Code: 0,
    Checksum: 0,
    Body: &icmp.Echo{
        ID: id,
        Seq: seq,
        Data: bytes,
    },
}
b, err := icmpMessage.Marshal(nil)
if err != nil {
    return nil, err
}
return &PingMsg{
    bytes: b,
    icmpMessage: icmpMessage,
}, nil

}

func ping(addr string) error{

conn, err := net.Dial("ip4:icmp", addr)
if err != nil {
    return err
}
defer conn.Close()
pingMsg, err := newEchoPingMessage(os.Getpid()&0xffff, 1)
if err != nil {
    return err
}
timeout := 5 * time.Second
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
    select {
    case <- ticker.C:
        if _, err = conn.Write(pingMsg.bytes); err != nil {
            return err
        }
    case <- time.After(timeout):
        return errors.New("request timeout")
    }
}

}

func receivePing(conn net.Conn ) error{

for {
    b := make([]byte, 512)
    conn.SetReadDeadline(time.Now().Add(time.Second))
    if n, err := conn.Read(b); err != nil {
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            continue
        }
        return err
    } else {
        recvMsg, err := icmp.ParseMessage(ipv4.ICMPTypeEchoReply, b[:n])
        if err != nil {
            return err
        }
        switch recvMsg.Type {
        case ipv4.ICMPTypeEchoReply:
            echoReply, _ := recvMsg.Body.(*icmp.EchoReply)
            log.Printf("ping %d bytes from %s: icmp_seq=%d time=%dms", len(echoReply.Data), conn.RemoteAddr().String(), echoReply.Seq, time.Since(time.Unix(0, echoReply.ArrivalTime().Nanoseconds())).Nanoseconds())
        default:
            log.Printf("unsupported ICMP message type %v (%v)", recvMsg.Type, recvMsg.Code)
        }
    }
}

}

func main(){

if err := ping("www.baidu.com"); err != nil{
    log.Fatal(err)
}

}

When this code is run, ICMP data will be sent continuously The packet is sent to the target host until the host times out or receives a reply. Whenever a reply packet is received, the program will output the following information:

ping 32 bytes from 120.92.6.25: icmp_seq=0 time=29ms

This means that the reply packet is successfully received. And the return trip time is displayed. The process of implementing Ping is very simple, but it does allow us to better understand the principles of network communication.

The above is the detailed content of How to implement ping in golang. For more information, please follow other related articles on the PHP Chinese website!