Example #1
2
func Pinger(address *net.IPAddr, timeout time.Duration) error {
	var (
		c   *net.IPConn
		err error
	)

	v6 := address.IP.To4() == nil

	if v6 {
		c, err = net.DialIP("ip6:ipv6-icmp", nil, address)
	} else {
		c, err = net.DialIP("ip4:icmp", nil, address)
	}
	if err != nil {
		return err
	}

	c.SetDeadline(time.Now().Add(timeout))
	defer c.Close()

	typ := icmpv4EchoRequest

	if v6 {
		typ = icmpv6EchoRequest
	}

	xid, xseq := os.Getpid()&0xffff, 1
	wb, err := (&icmpMessage{
		Type: typ, Code: 0,
		Body: &icmpEcho{
			ID: xid, Seq: xseq,
			Data: bytes.Repeat([]byte("Go Go Gadget Ping!!!"), 3),
		},
	}).Marshal()
	if err != nil {
		return err
	}
	if _, err = c.Write(wb); err != nil {
		return err
	}
	var m *icmpMessage
	rb := make([]byte, 20+len(wb))
	for {
		if _, err = c.Read(rb); err != nil {
			return err
		}
		if !v6 {
			rb = ipv4Payload(rb)
		}
		if m, err = parseICMPMessage(rb); err != nil {
			return err
		}

		switch m.Type {
		case icmpv4EchoRequest, icmpv6EchoRequest:
			continue
		}
		break
	}
	return nil
}
Example #2
0
func singleping(ip string) (time.Duration, error) {
	addr := net.IPAddr{IP: net.ParseIP(ip)}
	sendid := os.Getpid() & 0xffff
	sendseq := 1
	pingpktlen := 64
	sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte("Go Ping"))
	ipconn, err := net.DialIP("ip4:icmp", nil, &addr) // *IPConn (Conn 인터페이스 구현)
	if err != nil {
		log.Fatalf(`net.DialIP("ip4:icmp", %v) = %v`, ipconn, err)
	}
	ipconn.SetDeadline(time.Now().Add(time.Second)) //1 Second timeout
	start := time.Now()
	n, err := ipconn.WriteToIP(sendpkt, &addr)
	if err != nil || n != pingpktlen {
		log.Fatalf(`net.WriteToIP(..., %v) = %v, %v`, addr, n, err)
	}

	resp := make([]byte, 1024)
	_, _, pingerr := ipconn.ReadFrom(resp)
	if pingerr != nil {
		fmt.Printf("%s : FAIL\n", ip)
	} else {
		fmt.Printf("%s : %s\n", ip, time.Since(start))
	}

	// log.Printf("%x", resp)

	return time.Since(start), pingerr
}
Example #3
0
func sendIPPacket() {
	fmt.Println("go!")
	ipaddr, err := net.ResolveIPAddr("ip", "192.168.1.254")
	if err != nil {
		fmt.Println("IP address is wrong!")
		return
	}
	localAddrs, err := net.InterfaceAddrs()
	if err != nil {
		fmt.Println("Local interface is null!")
		return
	}
	lIPAddrs := getSendLocalIP(localAddrs, ipaddr)
	if lIPAddrs == nil {
		fmt.Println("Local interface is null!")
		return
	}
	fmt.Println(lIPAddrs.String())
	ipConn, err := net.DialIP("ip", &net.IPAddr{IP: lIPAddrs.IP, Zone: ""}, ipaddr)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	b := []byte{0xAA, 0xBB, 0xCC}
	_, err = ipConn.Write(b)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer ipConn.Close()
}
Example #4
0
func main() {
	var (
		icmp  ICMP
		laddr net.IPAddr = net.IPAddr{IP: net.ParseIP("192.168.34.125")}
		raddr net.IPAddr = net.IPAddr{IP: net.ParseIP("114.114.114.114")}
	)
	conn, err := net.DialIP("ip4:icmp", &laddr, &raddr)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()
	icmp.Type = 8 //8->echo message  0->reply message
	icmp.Code = 0
	icmp.Checksum = 0
	icmp.Identifier = 0
	icmp.SequenceNum = 0
	var (
		buffer bytes.Buffer
	)
	binary.Write(&buffer, binary.BigEndian, icmp)
	icmp.Checksum = CheckSum(buffer.Bytes())
	buffer.Reset()
	binary.Write(&buffer, binary.BigEndian, icmp)
	if _, err := conn.Write(buffer.Bytes()); err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Printf("send icmp packet success!")
}
Example #5
0
// Ping public method
func Ping(ip string) (bool, error) {
	recv := make([]byte, 1024)                //保存响应数据
	raddr, err := net.ResolveIPAddr("ip", ip) //raddr为目标主机的地址
	if err != nil {
		fmt.Spintf("resolve ip: %s fail:", ip)
		return false, err
	}
	laddr := net.IPAddr{IP: net.ParseIP("0.0.0.0")} //源地址
	if ip == "" {
		return false, errors.New("ip or domain is null")
	}

	conn, err := net.DialIP("ip4:icmp", &laddr, raddr)
	if err != nil {
		glog.Errorf("dial ip: %s fail:%v", laddr, err)
		return false, err
	}
	defer conn.Close()

	buffer := assemblyIcmp()
	if _, err := conn.Write(buffer.Bytes()); err != nil {
		fmt.Spintf("post Icmp fail: %v", err)
		return false, err
	}

	conn.SetReadDeadline((time.Now().Add(time.Second * 5)))
	_, err = conn.Read(recv)
	if err != nil {
		fmt.Spintf("get Icmp fail: %v", err)
		return false, nil
	}

	return true, nil
}
func ping(host string, timeLimit int) (re PingReturn) {
	re.success = false
	re.host = host
	PingLogger.Println("Ping ", host)
	raddr, err := net.ResolveIPAddr("ip", host)
	if err != nil {
		PingLogger.Println("resolve ip addr error", err)
		re.msg = "ip error"
		re.err = err
		return
	} else {
		PingLogger.Println("IP:", raddr)
	}
	conn, err := net.DialIP("ip4:icmp", nil, raddr)
	if err != nil {
		if strings.Index(err.Error(), "operation not permitted") != -1 {
			log.Fatalln("operation not permitted, please run it by sudo")
		}
		fmt.Printf("%+v\n", err.Error())
		PingLogger.Println(err)
		re.msg = "dial error"
		re.err = err
		return
	}
	var icmp ICMP
	icmp.Type = 8
	icmp.Code = 0
	icmp.Checksum = 0
	icmp.Identifier = 0
	icmp.SequenceNum = 0

	var buffer bytes.Buffer

	binary.Write(&buffer, binary.BigEndian, icmp)
	icmp.Checksum = CheckSum(buffer.Bytes())
	buffer.Reset()
	binary.Write(&buffer, binary.BigEndian, icmp)
	PingLogger.Println("Runing Ping data ",
		printByte(buffer.Bytes()))
	conn.Write(buffer.Bytes())
	t_start := time.Now()
	conn.SetReadDeadline((time.Now().Add(
		time.Duration(timeLimit) * time.Millisecond)))
	recv := make([]byte, 100)
	recv_len, err := conn.Read(recv)
	if err != nil {
		re.msg = "read error"
		re.err = err
		PingLogger.Println(err)
		return
	}
	PingLogger.Println("Recv data ", printByte(recv[:recv_len]))
	t_end := time.Now()
	dur := t_end.Sub(t_start).Nanoseconds() / 1e6
	PingLogger.Println("Time spend ms", dur)
	PingLogger.Println("")
	re.success = true
	defer conn.Close()
	return
}
Example #7
0
func main() {
	flag.Parse()
	if ipAddr == "(none)" || ipProto == -1 {
		log.Panic("usage")
	}
	ra, err := net.ResolveIPAddr("ip4", ipAddr)
	if err != nil {
		log.Panic(err)
	}
	proto := fmt.Sprintf("ip:%d", ipProto)
	conn, err := net.DialIP(proto, nil, ra)
	if err != nil {
		log.Panic(err)
	}
	defer conn.Close()
	in := bufio.NewReader(os.Stdin)
	line, err := in.ReadSlice('\n')
	for err == nil {
		_, err = conn.Write([]byte(line))
		if err != nil {
			log.Panic(err)
		}
		line, err = in.ReadSlice('\n')
	}
}
Example #8
0
File: sleeve.go Project: brb/weave
func (sender *udpSenderDF) dial() error {
	if sender.socket != nil {
		if err := sender.socket.Close(); err != nil {
			return err
		}

		sender.socket = nil
	}

	laddr := &net.IPAddr{IP: sender.localIP}
	raddr := &net.IPAddr{IP: sender.remoteIP}
	s, err := net.DialIP("ip4:UDP", laddr, raddr)

	f, err := s.File()
	if err != nil {
		return err
	}

	defer f.Close()

	// This makes sure all packets we send out have DF set on them.
	err = syscall.SetsockoptInt(int(f.Fd()), syscall.IPPROTO_IP, syscall.IP_MTU_DISCOVER, syscall.IP_PMTUDISC_DO)
	if err != nil {
		return err
	}

	sender.socket = s
	return nil
}
Example #9
0
func dialIP(conn *LocalConnection) (*net.IPConn, error) {
	ipLocalAddr, err := ipAddr(conn.TCPConn.LocalAddr())
	if err != nil {
		return nil, err
	}
	ipRemoteAddr, err := ipAddr(conn.TCPConn.RemoteAddr())
	if err != nil {
		return nil, err
	}
	ipSocket, err := net.DialIP("ip4:UDP", ipLocalAddr, ipRemoteAddr)
	if err != nil {
		return nil, err
	}
	f, err := ipSocket.File()
	if err != nil {
		return nil, err
	}
	defer f.Close()
	fd := int(f.Fd())
	// This Makes sure all packets we send out have DF set on them.
	err = syscall.SetsockoptInt(fd, syscall.IPPROTO_IP, syscall.IP_MTU_DISCOVER, syscall.IP_PMTUDISC_DO)
	if err != nil {
		return nil, err
	}
	return ipSocket, nil
}
Example #10
0
func main() {
	flag.Parse()
	dst := flag.Arg(0)
	//dst := "121.254.177.105"

	raddr, err := net.ResolveIPAddr("ip4", dst) // *IPAddr
	if err != nil {
		log.Fatalf(`net.ResolveIPAddr("ip4", %v") = %v, %v`, dst, raddr, err)
	}

	ipconn, err := net.DialIP("ip4:icmp", nil, raddr) // *IPConn (Conn 인터페이스 구현)
	if err != nil {
		log.Fatalf(`net.DialIP("ip4:icmp", %v) = %v`, ipconn, err)
	}

	sendid := os.Getpid() & 0xffff
	sendseq := 1
	pingpktlen := 64

	for {
		sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte("Go Ping"))

		//fmt.Printf("%v, %v\n", sendpkt[0:8], string(sendpkt[8:]))

		start := time.Now().UnixNano()

		n, err := ipconn.WriteToIP(sendpkt, raddr)
		if err != nil || n != pingpktlen {
			log.Fatalf(`net.WriteToIP(..., %v) = %v, %v`, raddr, n, err)
		}

		//ipconn.SetTimeout(5e8) // 0.5 second

		resp := make([]byte, 1024)
		for {
			n, from, err := ipconn.ReadFrom(resp)
			fmt.Printf("%d bytes from %s: icmp_req=%d time=%.2f ms\n", n, dst, sendseq, elapsedTime(start))

			// log.Printf("%x", resp)

			if err != nil {
				log.Fatalf(`ReadFrom(...) = %v, %v, %v`, n, from, err)
			}
			if resp[0] != ICMP_ECHO_REPLY {
				continue
			}
			rcvid, rcvseq := parsePingReply(resp)
			if rcvid != sendid || rcvseq != sendseq {
				log.Fatalf(`Ping reply saw id,seq=0x%x,0x%x (expected 0x%x, 0x%x)`, rcvid, rcvseq, sendid, sendseq)
			}
			break
		}

		sendseq++
		time.Sleep(1e9) // 1 second. like -i (interval) option
	}
}
Example #11
0
func send(s string) {
	log.Printf("sending to %s: %s", addr.String(), s)
	conn, err := net.DialIP(groupIPProto, nil, addr)
	if err != nil {
		log.Panic(err)
	}
	defer conn.Close()
	n, err := conn.Write([]byte(s))
	if err != nil {
		log.Panic(err)
	}
	log.Printf("sent %d bytes", n)
}
Example #12
0
func main() {
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, "Usage: %s host", os.Args[0])
		os.Exit(1)
	}

	dst := os.Args[1]
	raddr, err := net.ResolveIPAddr("ip4", dst)
	checkError(err)
	ipconn, err := net.DialIP("ip4:icmp", nil, raddr)
	checkError(err)

	sendid := os.Getpid() & 0xffff
	sendseq := 1
	pingpktlen := 64
	for {
		sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte(""))
		start := int64(time.Now().Nanosecond())
		_, err := ipconn.WriteToIP(sendpkt, raddr)
		checkError(err)

		resp := make([]byte, 1024)
		for {
			n, from, err := ipconn.ReadFrom(resp)
			checkError(err)
			fmt.Printf("%d bytes from %s: icmp_req = %d time = %.2f ms\n", n,
				from, sendseq, elapsedTime(start))

			if resp[0] != ICMP_ECHO_REPLY {
				continue
			}

			rcvid, rcvseq := parsePingReply(resp)
			if rcvid != sendid || rcvseq != sendseq {
				fmt.Println("Ping reply saw id ", rcvid, rcvseq, sendid, sendseq)
			}

			break
		}

		if sendseq == 4 {
			break
		} else {
			sendseq++
		}

		time.Sleep(1e9)
	}

}
func main() {

	if len(os.Args) != 2 {
		fmt.Printf("Usage: %s hostname\n", os.Args[0])
		os.Exit(1)
	}

	addr, err := net.ResolveIPAddr("ip", os.Args[1])
	if err != nil {
		fmt.Printf("Resolution error: %s\n", err.Error())
		os.Exit(1)
	}

	conn, err := net.DialIP("ip4:icmp", addr, addr)
	checkError(err)

	var msg [512]byte
	msg[0] = 8  // echo
	msg[1] = 0  // code 0
	msg[2] = 0  // checksum, fix later
	msg[3] = 0  // checksum, fix later
	msg[4] = 0  // identifier[0]
	msg[5] = 13 // identifier[1]
	msg[6] = 0  // sequence[0]
	msg[7] = 37 // sequence[1]
	len := 8

	check := checkSum(msg[0:len])

	msg[2] = byte(check >> 8)
	msg[3] = byte(check & 255)

	_, err = conn.Write(msg[0:len])
	checkError(err)

	_, err = conn.Read(msg[0:])
	checkError(err)

	fmt.Println("Got response")

	if msg[5] == 13 {
		fmt.Println("Identifier matches")
	}

	if msg[7] == 37 {
		fmt.Println("Sequence matches")
	}

	os.Exit(0)
}
Example #14
0
func TestPing(t *testing.T) {
	fmt.Println("flag args: ", flag.Args())

	if address == "" {
		t.Error("address is empty")
		os.Exit(1)
	}
	fmt.Println("address is ", address)
	addr, err := net.ResolveIPAddr("ip", address)
	if err != nil {
		fmt.Println("Resolution error", err.Error())
		os.Exit(1)
	}

	conn, err := net.DialIP("ip4:icmp", addr, addr)
	checkError(err)

	var msg [512]byte
	msg[0] = 8  // echo
	msg[1] = 0  // code 0
	msg[2] = 0  // checksum, fix later
	msg[3] = 0  // checksum, fix later
	msg[4] = 0  // identifier[0]
	msg[5] = 13 //identifier[1]
	msg[6] = 0  // sequence[0]
	msg[7] = 37 // sequence[1]
	len := 8

	check := checkSum(msg[0:len])
	msg[2] = byte(check >> 8)
	msg[3] = byte(check & 255)

	_, err = conn.Write(msg[0:len])
	checkError(err)

	_, err = conn.Read(msg[0:])
	checkError(err)

	fmt.Println("Got response")
	if msg[5] == 13 {
		fmt.Println("identifier matches")
	}
	if msg[7] == 37 {
		fmt.Println("Sequence matches")
	}

	os.Exit(0)
}
Example #15
0
func dialAddr(net, addr string, addri netpkg.Addr) (c netpkg.Conn, err error) {
	switch ra := addri.(type) {
	case *netpkg.TCPAddr:
		c, err = netpkg.DialTCP(net, nil, ra)
	case *netpkg.UDPAddr:
		c, err = netpkg.DialUDP(net, nil, ra)
	case *netpkg.IPAddr:
		c, err = netpkg.DialIP(net, nil, ra)
	default:
		err = errors.New("Unknown network address type")
	}
	if err != nil {
		return nil, err
	}
	return
}
Example #16
0
func send(s string) {
	if nSent > maxSends {
		log.Printf("sends capped at %d; not sending %s", maxSends, s)
		return
	}
	atomic.AddInt32(&nSent, 1)
	log.Printf("%20s to %s: %s", "SEND", sendDest.String(), s)
	conn, err := net.DialIP(groupIPProto, nil, sendDest)
	if err != nil {
		log.Panic(err)
	}
	defer conn.Close()
	_, err = conn.Write([]byte(s))
	if err != nil {
		log.Panic(err)
	}
}
func ping(host string) {
	log.Println("Ping ", host)
	raddr, err := net.ResolveIPAddr("ip", host)
	if err != nil {
		log.Fatalln("resolve ip addr error", err)
	} else {
		log.Println("IP:", raddr)
	}
	conn, err := net.DialIP("ip4:icmp", nil, raddr)
	if err != nil {
		log.Fatalln(err)
	}
	var icmp ICMP
	icmp.Type = 8
	icmp.Code = 0
	icmp.Checksum = 0
	icmp.Identifier = 0
	icmp.SequenceNum = 0
	var buffer bytes.Buffer
	binary.Write(&buffer, binary.BigEndian, icmp)
	icmp.Checksum = CheckSum(buffer.Bytes())
	buffer.Reset()
	binary.Write(&buffer, binary.BigEndian, icmp)
	log.Println("Runing Ping data ", printByte(buffer.Bytes()))
	conn.Write(buffer.Bytes())
	t_start := time.Now()
	conn.SetReadDeadline((time.Now().Add(time.Second * 5)))
	recv := make([]byte, 100)
	recv_len, err := conn.Read(recv)
	if err != nil {
		log.Fatalln(err)
	}

	// log.Println("Recv data check error", recv, buffer.Bytes())
	// }
	log.Println("Recv data ", printByte(recv[:recv_len]))
	t_end := time.Now()
	dur := t_end.Sub(t_start).Nanoseconds() / 1e6
	log.Println("Time spend ms", dur)
	log.Println("")
	defer conn.Close()
}
Example #18
0
func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage:", os.Args[0], "host")
		os.Exit(1)
	}
	addr, err := net.ResolveIPAddr("ip", os.Args[1])
	if err != nil {
		fmt.Println("Resolution error", err.Error())
		os.Exit(1)
	}

	conn, err := net.DialIP("ip4:icmp", nil, addr)
	checkError(err)
	var msg [512]byte
	msg[0] = 8
	msg[1] = 0
	msg[2] = 0
	msg[3] = 0
	msg[4] = 0
	msg[5] = 13
	msg[6] = 0
	msg[7] = 37
	len := 8
	check := checkSum(msg[0:len])
	msg[2] = byte(check >> 8)
	msg[3] = byte(check & 255)
	_, err = conn.Write(msg[0:len])
	checkError(err)
	_, err = conn.Read(msg[0:])
	checkError(err)
	fmt.Println("Got response")
	if msg[5] == 13 {
		fmt.Println("identifier matches")
	}

	if msg[7] == 37 {
		fmt.Println("Sequence mathces")
	}
	os.Exit(0)
}
Example #19
0
func main() {
	laddr := &net.IPAddr{IP: net.ParseIP("0.0.0.0")}
	raddr, err := net.ResolveIPAddr("ip", os.Args[1])
	if err != nil {
		log.Fatalln("parse remote addr error: ", err.Error())
	}

	conn, err := net.DialIP("ip4:icmp", laddr, raddr)
	if err != nil {
		log.Fatalln("dial ip failed", err.Error())
		return
	}
	defer conn.Close()

	payload, err := (&icmp.Message{
		Type: ipv4.ICMPTypeEcho, Code: 0,
		Body: &icmp.Echo{
			ID: 0, Seq: 0,
			Data: []byte("abcd"),
		},
	}).Marshal(nil)
	if err != nil {
		log.Fatalln("marshal echo error: ", err.Error())
	}
	log.Println(payload)
	numWrite, err := conn.Write(payload)
	if err != nil {
		log.Fatalln("write echo request error: ", err.Error())
	}
	log.Println("write size: ", numWrite)
	numRead, _, err := conn.ReadFrom(payload)
	if err != nil {
		log.Fatalln("read echo request error: ", err.Error())
	}
	log.Println("read size: ", numRead)

	for {
	}
}
Example #20
0
func main() {
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, "Usage:%s host", os.Args[0])
	}
	service := os.Args[1]
	lAddr, err := net.ResolveTCPAddr("ip4", service)
	checkError(err)
	name, err := os.Hostname()
	checkError(err)
	rAddr, err := net.ResolveIPAddr("ip4", name)
	checkError(err)
	conn, err := net.DialIP("ip4:ip", lAddr, rAddr)
	checkError(err)
	_, err = conn.WriteToIP([]byte("Hello Server!"), rAddr)
	checkError(err)
	var buf [512]byte
	n, addr, err := conn.ReadFromIP(buf[0:])
	checkError(err)
	fmt.Println("Reply form server", addr.String(), string(buf[0:n]))
	conn.Close()
	os.Exit(0)
}
Example #21
0
func NewICMPPacketClient(server string) (*ICMPPacketClient, error) {
	addr, err := net.ResolveIPAddr("ip", server)
	if err != nil {
		return nil, err
	}

	conn, err := net.DialIP("ip:icmp", nil, addr)
	if err != nil {
		return nil, err
	}

	// TODO: start the read process.
	send_ch := make(chan []byte)
	recv_ch := make(chan []byte)
	client := &ICMPPacketClient{conn, send_ch, recv_ch, true}

	// TODO: cross-platform!
	old_val, err := ChangeIgnorePings(false)
	if err != nil {
		client.old_icmp_val = old_val
	}

	return nil, nil
}
Example #22
0
func sendICMPPacket(host string, count int) StasticData {
	addr, err := net.ResolveIPAddr("ip", host)
	if err != nil {
		fmt.Println("Resolve Address Error", err.Error())
		os.Exit(1)
	}
	laddr := net.IPAddr{IP: net.ParseIP("0.0.0.0")}

	conn, err := net.DialIP("ip4:icmp", &laddr, addr)
	checkErr(err)
	defer conn.Close()

	var icmp ICMP
	icmp.Type = 8
	icmp.Code = 0
	icmp.Checksum = 0
	icmp.Identifier = 13
	icmp.Sequence = 40

	var buffer bytes.Buffer
	binary.Write(&buffer, binary.BigEndian, icmp)
	icmp.Checksum = checksum(buffer.Bytes())
	buffer.Reset()
	binary.Write(&buffer, binary.BigEndian, icmp)

	var result StasticData
	result.Host = host
	result.Count = int32(count)
	result.DurationList = list.New()

	fmt.Printf("\nPing %s (%s) 0 bytes of data\n", host, addr.IP.To16())

	for i := 0; i < count; i++ {
		_, err = conn.Write(buffer.Bytes())
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error : %s\n", err.Error())
			continue
		}
		tNow := time.Now()
		result.SendedPackets++
		// fmt.Println("Send icmp packet successfully")

		//read timeout
		//TODO: could be configurable
		conn.SetReadDeadline(tNow.Add(1 * time.Second))
		recv := make([]byte, 512)
		_, err = conn.Read(recv)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error : %s\n", err.Error())
			continue
		}

		tEnd := time.Now()

		duration := int32(tEnd.Sub(tNow).Nanoseconds() / (1000 * 1000))
		fmt.Printf("from %s (%s) : time=%dms\n", host, addr.String(), duration)
		result.DurationList.PushBack(duration)

		// fmt.Println(recv)
	}
	return result

}
Example #23
0
func (self *HikarianIcmp) transportClient(clientConn *net.TCPConn) {
	wb := make([]byte, 10240)
	host, port, err := net.SplitHostPort(clientConn.RemoteAddr().String())
	if err != nil {
		log.Fatal("split host port error: ", err.Error())
		return
	}
	ip4 := strings.Split(host, ".")
	id := 0
	for index, value := range ip4 {
		log.Println(index, value)
		i, err := strconv.Atoi(value)
		if err != nil {
			log.Println("strconv ip error: ", err.Error())
			continue
		}
		id += int(uint(i) >> uint(index))
	}
	seq, err := strconv.Atoi(port)
	if err != nil {
		log.Println("strconv port error: ", err.Error())
	}

	//server
	laddr := &net.IPAddr{IP: net.ParseIP("0.0.0.0")}
	raddr, err := net.ResolveIPAddr("ip", self.server)
	if err != nil {
		log.Fatalln("parse remote addr error: ", err.Error())
	}

	serverConn, err := net.DialIP("ip4:icmp", laddr, raddr)
	if err != nil {
		log.Fatalln("dial ip failed", err.Error())
		return
	}
	// defer serverConn.Close()
	readChannel := make(chan []byte)
	go func() {
		for {
			rb := make([]byte, 1024)
			log.Println("wait client data")
			nr, _, err := serverConn.ReadFrom(rb)
			log.Println("get client data size ", nr)
			if err != nil {
				if err != io.EOF {
					log.Println("read server error: ", err)
					break
				}
			}

			reply, err := icmp.ParseMessage(ProtocolICMP, rb)
			if err != nil {
				log.Println("parse icmp echo reply error: ", err.Error())
				break
			}

			if reply.Code != MagicCode {
				break
			}

			body, err := reply.Body.Marshal(ProtocolICMP)
			if err != nil {
				log.Println("marshal icmp echo reply body error: ", err.Error())
				break
			}

			log.Printf("get echo reply id:%d and seq:%d",
				binary.BigEndian.Uint16(body[0:2]),
				binary.BigEndian.Uint16(body[2:4]))
			if binary.BigEndian.Uint16(body[0:2]) == uint16(id) &&
				binary.BigEndian.Uint16(body[2:4]) == uint16(seq) {
				log.Println("right")
				readChannel <- body[4 : nr-4]
				// break
			} else {
				log.Println("receive other")
				continue
			}
		}
		close(readChannel)
	}()

	go func() {
		for {
			body, ok := <-readChannel
			if ok == false {
				return
			}
			nr, err := clientConn.Write(body)
			if err != nil {
				log.Println("write client error: ", err.Error())
				return
			}
			log.Println("get echo reply size ", nr)
		}
	}()
	done := make(chan bool)
	go func() {
		for {
			size := 0
			rb := make([]byte, 1024)
			log.Println("wait client")
			nr, err := clientConn.Read(rb)
			log.Println("get client data size ", nr)
			if err != nil {
				if err != io.EOF {
					log.Println("read server error: ", err.Error())
					break
				} else {
					log.Println("EOF")
					break
				}
			}
			if nr > 0 {
				wb = append(wb[:size], rb[:nr]...)
				size += nr
			}

			log.Printf("set echo request id:%d and seq:%d", id, seq)
			payload, err := (&icmp.Message{
				Type: ipv4.ICMPTypeEcho, Code: MagicCode,
				Body: &icmp.Echo{
					ID: id, Seq: seq,
					Data: wb[:size],
				},
			}).Marshal(nil)
			if err != nil {
				log.Fatalln("marshal echo error: ", err.Error())
			}
			nw, err := serverConn.Write(payload)
			if err != nil {
				log.Fatalln("write echo request error: ", err.Error())
			}
			log.Println("write server ", nw)
		}
		done <- true
	}()
	<-done
}
Example #24
0
File: main.go Project: kriben/ping
func main() {
	usage := `Ping.

Usage:
  ping [--count COUNT] DESTINATION

Options:
  -h --help                Show this message.
  -c, --count COUNT   Send this many pings [default: 20].`

	arguments, _ := docopt.Parse(usage, nil, true, "Ping", false)
	host := arguments["DESTINATION"].(string)
	numPings := 20
	if arguments["--count"] != nil {
		numPings, _ = strconv.Atoi(arguments["--count"].(string))
	}

	rAddr, err := net.ResolveIPAddr("ip4", host)
	if err != nil {
		panic(err)
	}

	fmt.Printf("PING %s (%s)\n", host, rAddr)

	conn, err := net.DialIP("ip4:icmp", nil, rAddr)
	if err != nil {
		panic(err)
	}

	defer conn.Close()

	pid := os.Getpid()
	var id1 = byte(pid & 0xff00 >> 8)
	var id2 = byte(pid & 0xff)

	var timeout = 1 * time.Second
	var interval = 1 * time.Second
	var messageLength = 8

	pingTimes := []time.Duration{}
	for i := 0; i < numPings; i++ {

		msg := MakeEchoRequest(i, messageLength, id1, id2)

		startTime := time.Now()
		deadline := startTime.Add(timeout)
		conn.SetDeadline(deadline)

		if _, err = conn.Write(msg[0:messageLength]); err != nil {
			continue
		}

		response := make([]byte, 64)
		for {
			numRead, _, err := conn.ReadFrom(response)
			if err != nil {
				panic(err)
			}

			if response[0] == 0 {
				duration := time.Since(startTime)
				fmt.Printf("%d bytes from %s (%s): time=%v\n",
					numRead,
					host, rAddr,
					duration)
				pingTimes = append(pingTimes, duration)
			}

			break
		}

		time.Sleep(interval)
	}

	fmt.Printf("--- %s statistics ---\n", host)
	total, min, max, avg := ComputeStats(pingTimes)
	fmt.Printf("total = %v\n", total)
	fmt.Printf("rtt min = %v\n", min)
	fmt.Printf("rtt max = %v\n", max)
	fmt.Printf("rtt avg = %v\n", avg)
}
Example #25
0
func fillARP(ifin string) {
	defer wg.Done()
	ifi, err := net.InterfaceByName(ifin)
	if err != nil {
		log.Fatal(err)
	}
	ifat, err := ifi.Addrs()
	if err != nil {
		log.Fatal(err)
	}
	var bs = []byte{0}
	for _, addr := range ifat {
		saddr := addr.String()[:strings.IndexRune(addr.String(), '/')]
		if strings.Contains(saddr, ":") {
			continue
		}
		la := &net.IPAddr{
			IP: net.ParseIP(saddr),
		}
		maskSize, err := strconv.ParseUint(addr.String()[len(saddr)+1:], 10, 6)
		if err != nil {
			log.Fatal(err)
		}
		mSizeLeft := byte(maskSize)
		mask := make(net.IPMask, 4)
		var lastMaskOct int
		for lastMaskOct = 12; lastMaskOct < 16; lastMaskOct++ {
			if n := mSizeLeft - 8; n > 0 && n <= 32 {
				mSizeLeft = n
				mask[lastMaskOct-12] = 255
			} else {
				mask[lastMaskOct-12] = ^byte(math.Pow(2, float64((8-mSizeLeft))) - 1)
				break
			}
		}
		var ping func(net.IP, int)
		ping = func(rip net.IP, oct int) {
			var start byte
			var max byte
			if oct == lastMaskOct {
				start = mask[lastMaskOct-12] & rip[lastMaskOct]
				max = ^mask[lastMaskOct-12] + start
			} else {
				max = 255
			}
			for rip[oct] = start; rip[oct] <= max; rip[oct]++ {
				nip := make(net.IP, 16)
				copy(nip, rip)
				if oct != 15 {
					ping(nip, oct+1)
					continue
				}
				wg.Add(1)
				go func(rip net.IP) {
					defer wg.Done()
					ra := &net.IPAddr{
						IP: net.ParseIP(rip.String()),
					}
					ipc, err := net.DialIP("ip4", la, ra)
					if err != nil {
						log.Println(err)
					}
					defer ipc.Close()
					ipc.Write(bs)
				}(nip)
				if rip[oct] == 255 {
					break
				}
				time.Sleep(time.Millisecond * 20)
			}
		}
		ping(net.ParseIP(la.IP.Mask(mask).String()), lastMaskOct)
	}
}
Example #26
0
File: icmp.go Project: adoyee/probe
func Pinger(laddr, address string, timeout int) error {
	// c, err := net.Dial("ip4:icmp", address)
	lip, e := net.ResolveIPAddr("ip4", laddr)
	if e != nil {
		return e
	}
	rip, e := net.ResolveIPAddr("ip4", address)
	if e != nil {
		return e
	}
	c, err := net.DialIP("ip4:icmp", lip, rip)
	if err != nil {
		return err
	}
	c.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
	defer c.Close()
	typ := icmpv4EchoRequest
	xid, xseq := os.Getpid()&0xffff, 1
	wb, err := (&icmpMessage{
		Type: typ, Code: 0,
		Body: &icmpEcho{
			ID: xid, Seq: xseq,
			Data: bytes.Repeat([]byte("Go Go Gadget Ping!!!"), 3),
		},
	}).Marshal()
	if err != nil {
		return err
	}

	tries := 3
	for i := 0; i < tries; i++ {

		if _, err = c.Write(wb); err != nil {
			return err
		}

		var m *icmpMessage
		rb := make([]byte, 20+len(wb))

		c.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Millisecond))
		_, err = c.Read(rb)

		if err != nil {
			if nerr, ok := err.(net.Error); ok && nerr.Timeout() && i < 2 {

				continue
			} else {
				return err
			}
		}
		rb = ipv4Payload(rb)
		if m, err = parseICMPMessage(rb); err != nil {
			return err
		}
		switch m.Type {
		case icmpv4EchoRequest, icmpv6EchoRequest:
		}
		break
	}
	return nil
}
Example #27
0
File: main.go Project: leo-lu/GO
func main() {
	if 2 > len(os.Args) {
		fmt.Println("input: IPAddr")
		return
	}
	var (
		icmp     ICMP
		laddr    = net.IPAddr{IP: net.ParseIP("0.0.0.0")}
		raddr, _ = net.ResolveIPAddr("ip", os.Args[1])
	)
	conn, err := net.DialIP("ip4:icmp", &laddr, raddr)
	checkErr(err)

	icmp.Type = 8
	icmp.Code = 0
	icmp.Checksum = 0
	icmp.Identifier = 0
	icmp.SequenceNum = 0

	var buff bytes.Buffer
	binary.Write(&buff, binary.BigEndian, icmp)
	icmp.Checksum = Checksum(buff.Bytes())
	buff.Reset()
	binary.Write(&buff, binary.BigEndian, icmp)

	fmt.Println("\n正在 Ping %s 具有 0 字节的数据:\n", raddr.String())
	recv := make([]byte, 1024)

	statistic := list.New()
	sended_packets := 0

	for i := 4; i > 0; i-- {
		if _, err := conn.Write(buff.Bytes()); err != nil {
			fmt.Println(err.Error())
			return
		}
		sended_packets++
		t_start := time.Now()
		conn.SetReadDeadline((time.Now().Add(time.Second * 5)))
		_, err := conn.Read(recv)

		if err != nil {
			fmt.Println("请求超时")
			continue
		}
		t_end := time.Now()
		dur := t_end.Sub(t_start).Nanoseconds() / 1e6
		fmt.Printf("来自 %s 的回复:时间 = %dms\n", raddr.String(), dur)
		statistic.PushBack(dur)
	}

	defer conn.Close()

	defer func() {
		fmt.Println("")
		//信息统计
		var min, max, sum int64
		if statistic.Len() == 0 {
			min, max, sum = 0, 0, 0
		} else {
			min, max, sum = statistic.Front().Value.(int64), statistic.Front().Value.(int64), int64(0)
		}

		for v := statistic.Front(); v != nil; v = v.Next() {

			val := v.Value.(int64)

			switch {
			case val < min:
				min = val
			case val > max:
				max = val
			}

			sum = sum + val
		}
		recved, losted := statistic.Len(), sended_packets-statistic.Len()
		fmt.Printf("%s 的 Ping 统计信息:\n  数据包:已发送 = %d,已接收 = %d,丢失 = %d (%.1f%% 丢失),\n往返行程的估计时间(以毫秒为单位):\n  最短 = %dms,最长 = %dms,平均 = %.0fms\n",
			raddr.String(),
			sended_packets, recved, losted, float32(losted)/float32(sended_packets)*100,
			min, max, float32(sum)/float32(recved),
		)
	}()
}
Example #28
0
// Ping
func Ping(addr string, i int) bool {

	// *IPAddr
	raddr, e := net.ResolveIPAddr("ip4", addr)
	if e != nil {
		return false
	}

	// *IPConn
	ipconn, ee := net.DialIP("ip4:icmp", nil, raddr)
	if ee != nil {
		return false
	}

	// 保证连接正常关闭
	defer ipconn.Close()

	// PID
	sendid := os.Getpid() & 0xffff
	sendseq := 1
	pingpktlen := 64

	for {

		sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte("Go Ping"))

		// 发送请求
		n, err := ipconn.WriteToIP(sendpkt, raddr)
		if err != nil || n != pingpktlen {
			break
		}

		// 超时
		ipconn.SetDeadline(time.Now().Add(5 * time.Second))

		// 返回数据
		resp := make([]byte, 1024)
		for {

			// 读取返回
			_, _, err := ipconn.ReadFrom(resp)
			if err != nil {
				break
			}

			// 判断状态
			if resp[0] != ICMP_ECHO_REPLY {
				continue
			}

			// 判断状态
			rcvid, rcvseq := parsePingReply(resp)
			if rcvid != sendid || rcvseq != sendseq {
				break
			}

			// 成功返回
			return true

		}

		// 执行次数内未成功返回
		if i == sendseq {
			break
		}

		// 计数器
		sendseq++

	}

	// 失败返回
	return false
}
Example #29
0
func PingIP(hostname string, raddr *net.IPAddr, pcount int, debug bool) (sent int, received int, etimes []float64) {
	// Make the IP connection to the destination host
	ipconn, err := net.DialIP("ip4:icmp", nil, raddr)
	if err != nil {
		fmt.Printf("could not connect to %s: %v\n", raddr.IP, err)
		return
	}

	sendid := os.Getpid() & 0xffff
	sendseq := 1
	pingpktlen := 64

	//if debug {
	fmt.Printf("PING %s (%s): %d data bytes\n", hostname, raddr.String(), pingpktlen-8)
	//}

	for {
		var check4reply bool
		var etime float64

		// Generate our ICMP packet
		sendpkt := makePingRequest(sendid, sendseq, pingpktlen, []byte("Go Ping"))

		// Start timer
		start := time.Now()

		// Send ICMP packet
		n, err := ipconn.Write(sendpkt)

		// Err out if we couldn't send the full packet size
		if err != nil || n != pingpktlen {
			etime = elapsedTime(start)
			fmt.Printf("0 bytes from %s: icmp_req=%d time=%.3f ms ERR: Network is down\n", raddr.IP, sendseq, etime)
		} else {
			// We will check this flag later to see if we need to wait for a returned packet
			check4reply = true
		}

		// increment our sent counter
		sent++

		// set a 0.5 second timer as our max packet reply wait time
		var deadline = start.Add(500 * time.Millisecond)
		ipconn.SetReadDeadline(deadline)

		// Read response packet (or process timeout if it occurs)
		resp := make([]byte, 1024)
		for {
			if check4reply == false {
				break
			}

			n, _, err := ipconn.ReadFrom(resp)
			if err != nil {
				// Could not read response packet
				etime = elapsedTime(start)
				if debug {
					fmt.Printf("%d bytes from %s: icmp_req=%d time=%.3f ms ERR: %s\n", n, raddr.IP, sendseq, etime, err.Error())
				}
				break
			} else {
				// Response was okay

			}

			if resp[0] != ICMP_ECHO_REPLY {
				// Skip non-ICMP packets
				continue
			}

			rcvid, rcvseq := parsePingReply(resp)
			if rcvid != sendid || rcvseq != sendseq {
				etime = elapsedTime(start)
				if debug {
					fmt.Printf("%d bytes from %s: icmp_req=%d time=%.3f ms ERR: Out of sequence (0x%x,0x%x)\n", n, raddr.IP, sendseq, etime, rcvid, rcvseq)
				}
			} else {
				// Packet reply came back okay
				etime = elapsedTime(start)
				if debug {
					fmt.Printf("%d bytes from %s: icmp_req=%d time=%.3f ms\n", n, raddr.IP, sendseq, etime)
				}
				received++
				etimes = append(etimes, etime)
			}
			break
		}

		sendseq++
		if sendseq > pcount {
			// We've reached the maximum number of packets to send so return
			return
		} else {
			// Sleep 1 second before moving onto the next packet
			time.Sleep(1 * time.Second)
		}
	}
}