ping.go

   1 package main
   2
   3 // Copyright 2009 The Go Authors.  All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // taken from http://golang.org/src/pkg/net/ipraw_test.go
   8
   9 import (
  10         "bytes"
  11         "errors"
  12         "net"
  13         "os"
  14         "time"
  15 )
  16
  17 func testPing(ip string, config *ScanConfig, record *ScanRecord) bool {
  18         start := time.Now()
  19         if err := Pinger(ip, config.ScanMaxRTT); err != nil {
  20                 return false
  21         }
  22         if rtt := time.Since(start); rtt > config.ScanMinRTT {
  23                 record.RTT += rtt
  24                 return true
  25         }
  26         return false
  27 }
  28
  29 const (
  30         icmpv4EchoRequest = 8
  31         icmpv4EchoReply   = 0
  32         icmpv6EchoRequest = 128
  33         icmpv6EchoReply   = 129
  34 )
  35
  36 var ErrPingConnFailed = errors.New("ping: connect failed")
  37
  38 type icmpMessage struct {
  39         Type     int             // type
  40         Code     int             // code
  41         Checksum int             // checksum
  42         Body     icmpMessageBody // body
  43 }
  44
  45 type icmpMessageBody interface {
  46         Len() int
  47         Marshal() ([]byte, error)
  48 }
  49
  50 // Marshal returns the binary enconding of the ICMP echo request or
  51 // reply message m.
  52 func (m *icmpMessage) Marshal() ([]byte, error) {
  53         b := []byte{byte(m.Type), byte(m.Code), 0, 0}
  54         if m.Body != nil && m.Body.Len() != 0 {
  55                 mb, err := m.Body.Marshal()
  56                 if err != nil {
  57                         return nil, err
  58                 }
  59                 b = append(b, mb...)
  60         }
  61         switch m.Type {
  62         case icmpv6EchoRequest, icmpv6EchoReply:
  63                 return b, nil
  64         }
  65         csumcv := len(b) - 1 // checksum coverage
  66         s := uint32(0)
  67         for i := 0; i < csumcv; i += 2 {
  68                 s += uint32(b[i+1])<<8 | uint32(b[i])
  69         }
  70         if csumcv&1 == 0 {
  71                 s += uint32(b[csumcv])
  72         }
  73         s = s>>16 + s&0xffff
  74         s = s + s>>16
  75         // Place checksum back in header; using ^= avoids the
  76         // assumption the checksum bytes are zero.
  77         b[2] ^= byte(^s & 0xff)
  78         b[3] ^= byte(^s >> 8)
  79         return b, nil
  80 }
  81
  82 // parseICMPMessage parses b as an ICMP message.
  83 func parseICMPMessage(b []byte) (*icmpMessage, error) {
  84         msglen := len(b)
  85         if msglen < 4 {
  86                 return nil, errors.New("message too short")
  87         }
  88         m := &icmpMessage{Type: int(b[0]), Code: int(b[1]), Checksum: int(b[2])<<8 | int(b[3])}
  89         if msglen > 4 {
  90                 var err error
  91                 switch m.Type {
  92                 case icmpv4EchoRequest, icmpv4EchoReply, icmpv6EchoRequest, icmpv6EchoReply:
  93                         m.Body, err = parseICMPEcho(b[4:])
  94                         if err != nil {
  95                                 return nil, err
  96                         }
  97                 }
  98         }
  99         return m, nil
 100 }
 101
 102 // imcpEcho represenets an ICMP echo request or reply message body.
 103 type icmpEcho struct {
 104         ID   int    // identifier
 105         Seq  int    // sequence number
 106         Data []byte // data
 107 }
 108
 109 func (p *icmpEcho) Len() int {
 110         if p == nil {
 111                 return 0
 112         }
 113         return 4 + len(p.Data)
 114 }
 115
 116 // Marshal returns the binary enconding of the ICMP echo request or
 117 // reply message body p.
 118 func (p *icmpEcho) Marshal() ([]byte, error) {
 119         b := make([]byte, 4+len(p.Data))
 120         b[0], b[1] = byte(p.ID>>8), byte(p.ID&0xff)
 121         b[2], b[3] = byte(p.Seq>>8), byte(p.Seq&0xff)
 122         copy(b[4:], p.Data)
 123         return b, nil
 124 }
 125
 126 // parseICMPEcho parses b as an ICMP echo request or reply message body.
 127 func parseICMPEcho(b []byte) (*icmpEcho, error) {
 128         bodylen := len(b)
 129         p := &icmpEcho{ID: int(b[0])<<8 | int(b[1]), Seq: int(b[2])<<8 | int(b[3])}
 130         if bodylen > 4 {
 131                 p.Data = make([]byte, bodylen-4)
 132                 copy(p.Data, b[4:])
 133         }
 134         return p, nil
 135 }
 136
 137 func Ping(address string, timeout time.Duration) error {
 138         return Pinger(address, timeout)
 139 }
 140
 141 func Pinger(address string, timeout time.Duration) error {
 142         typ := icmpv4EchoRequest
 143         network := "ip4:icmp"
 144
 145         isIpv6 := false
 146         if ip := net.ParseIP(address); ip != nil && ip.To4() == nil {
 147                 typ = icmpv6EchoRequest
 148                 network = "ip6:ipv6-icmp"
 149                 isIpv6 = true
 150         }
 151
 152         c, err := net.Dial(network, address)
 153         if err != nil {
 154                 return ErrPingConnFailed
 155         }
 156         defer c.Close()
 157         deadline := time.Now().Add(timeout)
 158         c.SetReadDeadline(deadline)
 159
 160         xid, xseq := os.Getpid()&0xffff, 1
 161         wb, err := (&icmpMessage{
 162                 Type: typ, Code: 0,
 163                 Body: &icmpEcho{
 164                         ID: xid, Seq: xseq,
 165                         Data: bytes.Repeat([]byte("Go Go Gadget Ping!!!"), 3),
 166                 },
 167         }).Marshal()
 168         if err != nil {
 169                 return err
 170         }
 171         if _, err = c.Write(wb); err != nil {
 172                 return err
 173         }
 174         var m *icmpMessage
 175         rb := make([]byte, 20+len(wb))
 176         for {
 177                 // read_timeout := deadline.Sub(time.Now())
 178                 // c.SetReadDeadline(time.Now().Add(read_timeout))
 179                 if _, err = c.Read(rb); err != nil {
 180                         return err
 181                 }
 182                 if !isIpv6 {
 183                         rb = ipv4Payload(rb)
 184                 }
 185                 if m, err = parseICMPMessage(rb); err != nil {
 186                         return err
 187                 }
 188                 switch m.Type {
 189                 case icmpv4EchoRequest, icmpv6EchoRequest:
 190                         continue
 191                 }
 192                 break
 193         }
 194         return nil
 195 }
 196
 197 func ipv4Payload(b []byte) []byte {
 198         if len(b) < 20 {
 199                 return b
 200         }
 201         hdrlen := int(b[0]&0x0f) << 2
 202         return b[hdrlen:]
 203 }