tracer/tracer.go

package main

import (
 _ "embed"
 "flag"
 "fmt"
 "log"
 "net"
 "strconv"
 "strings"
 "time"

 "io/ioutil"
 "net/http"
 "net/url"

 "encoding/json"

 "github.com/aeden/traceroute"
 "github.com/oschwald/maxminddb-golang"
)

var isFinish bool = false
var destIP net.IP

func remove(slice []string, s int) []string {
 if s < len(slice) {
 return append(slice[:s], slice[s+1:]...)
 }
 return slice
}

func removeEmpty(slice []string) (ret []string) {
 for i := 0; i < len(slice); i++ {
 if (len(slice[i])) != 0 {
 ret = append(ret, slice[i])
 }
 }
 return
}

type record struct {
 ASN int `maxminddb:"autonomous_system_number"`
 ASO string `maxminddb:"autonomous_system_organization"`
}

type IPDetail struct {
 Country string `json:"country"`
 Province string `json:"province"`
 City string `json:"city"`
 ISP string `json:"isp"`
}

type APIResponse struct {
 Code int `json:"code"`
 Detail IPDetail `json:"data"`
}

//go:embed `GeoLite2-ASN.mmdb`
var buffer []byte

func parseIPFromMap42(ip net.IP) (record, APIResponse, error) {
 params := url.Values{}

 URL, err := url.Parse("http://ipip.map.dn42/whois")

 if err != nil {
 return record{}, APIResponse{}, err
 }

 params.Set("ip", ip.String())
 params.Set("lang", "cn")

 URL.RawQuery = params.Encode()

 resp, err := http.Get(URL.String())

 if err != nil {
 return record{}, APIResponse{}, err
 }

 defer resp.Body.Close()

 body, _ := ioutil.ReadAll(resp.Body)
 var res struct {
 ASN string `json:"as"`
 Area string `json:"area"`
 }
 _ = json.Unmarshal(body, &res)

 ASN, err := strconv.Atoi(strings.Replace(res.ASN, "AS", "", -1))
 if err != nil {
 return record{}, APIResponse{}, err
 }

 record := record{
 ASN: ASN,
 }

 APIResponse := APIResponse{
 Code: 0,
 Detail: IPDetail{
 ISP: strings.Join(removeEmpty(remove(remove(strings.Split(res.Area, "\t"), 6), 5)), " "),
 },
 }
 return record, APIResponse, nil
}

func parseIPFromMaxminddb(ip net.IP) record {
 db, err := maxminddb.FromBytes(buffer)
 if err != nil {
 log.Fatal(err)
 }
 defer db.Close()

 var record record

 err = db.Lookup(ip, &record)

 if err != nil {
 log.Fatal(err)
 }

 return record
}

func parseIPFromBilibiliAPI(ip net.IP) APIResponse {
 params := url.Values{}

 URL, err := url.Parse("https://api.live.bilibili.com/client/v1/Ip/getInfoNew")

 if err != nil {
 log.Fatal(err)
 }

 params.Set("ip", ip.String())

 URL.RawQuery = params.Encode()

 resp, err := http.Get(URL.String())

 if err != nil {
 log.Fatal(err)
 }

 defer resp.Body.Close()

 body, _ := ioutil.ReadAll(resp.Body)
 var res APIResponse
 _ = json.Unmarshal(body, &res)
 return res
}

func printHop(hop traceroute.TracerouteHop) {
 addr := address(hop.Address)
 ip := net.ParseIP(addr)

 var info record
 var APIResponse APIResponse
 var err error

 if _, Prefix, _ := net.ParseCIDR("172.16.0.0/12"); Prefix.Contains(ip) {
 info, APIResponse, err = parseIPFromMap42(ip)
 if err != nil {
 info = parseIPFromMaxminddb(ip)
 APIResponse = parseIPFromBilibiliAPI(ip)
 }
 } else {
 info = parseIPFromMaxminddb(ip)
 APIResponse = parseIPFromBilibiliAPI(ip)
 }

 hostOrAddr := addr

 if hop.Host != "" {
 hostOrAddr = hop.Host
 }

 var ASN string

 if hop.Success {
 if info.ASN == 0 {
 ASN = "unknown"
 } else {
 ASN = fmt.Sprintf("AS%v", info.ASN)
 }
 if APIResponse.Code != 0 {
 fmt.Printf("%-3d %8v %15v %18v %8v\n", hop.TTL, ASN, hostOrAddr, "("+addr+")", hop.ElapsedTime.Round(time.Microsecond))
 } else {
 fmt.Printf("%-3d %8v %15v %18v %8v ", hop.TTL, ASN, hostOrAddr, "("+addr+")", hop.ElapsedTime.Round(time.Microsecond))

 var flag bool = false

 if APIResponse.Detail.Country != "" {
 flag = true
 fmt.Printf(APIResponse.Detail.Country)
 }
 if APIResponse.Detail.Province != "" {
 if flag {
 fmt.Printf(", ")
 }
 fmt.Print(APIResponse.Detail.Province)
 flag = true
 }
 if APIResponse.Detail.City != "" {
 if flag {
 fmt.Printf(", ")
 }
 fmt.Print(APIResponse.Detail.City)
 flag = true
 }

 if APIResponse.Detail.ISP != "" {
 if flag {
 fmt.Print(" ")
 }
 fmt.Print(APIResponse.Detail.ISP)
 flag = true
 }

 fmt.Printf("\n")
 }

 } else {
 fmt.Printf("%-3d *\n", hop.TTL)
 }

 if destIP.Equal(ip) {
 isFinish = true
 }

}

func address(address [4]byte) string {
 return fmt.Sprintf("%v.%v.%v.%v", address[0], address[1], address[2], address[3])
}

func main() {
 var m = flag.Int("m", traceroute.DEFAULT_MAX_HOPS, `Set the max time-to-live (max number of hops) used in outgoing probe packets (default is 64)`)
 var f = flag.Int("f", traceroute.DEFAULT_FIRST_HOP, `Set the first used time-to-live, e.g. the first hop (default is 1)`)
 var q = flag.Int("q", 1, `Set the number of probes per "ttl" to nqueries (default is one probe).`)

 flag.Parse()
 host := flag.Arg(0)
 options := traceroute.TracerouteOptions{}
 options.SetRetries(*q - 1)
 options.SetMaxHops(*m)
 options.SetFirstHop(*f)

 ipAddr, err := net.ResolveIPAddr("ip", host)
 if err != nil {
 return
 }

 fmt.Printf("traceroute to %v (%v), %v hops max, %v byte packets, using ICMP methods.\n", host, ipAddr, options.MaxHops(), options.PacketSize())

 c := make(chan traceroute.TracerouteHop, 0)
 d := make(chan bool)
 go func() {
 for {
 hop, ok := <-c
 if !ok {
 fmt.Println()
 return
 }
 printHop(hop)
 d <- true
 }
 }()

 destIP = ipAddr.IP

 _, err = traceroute.Traceroute(ipAddr.String(), &options, d, c)
 if err != nil {
 fmt.Printf("Error: %v", err)
 }
}