401 lines
8.9 KiB
Go
401 lines
8.9 KiB
Go
package qqwry
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/binary"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"io/ioutil"
|
||
"net"
|
||
"net/http"
|
||
"net/url"
|
||
"os"
|
||
"regexp"
|
||
"strings"
|
||
"sync"
|
||
|
||
_ "embed"
|
||
|
||
"github.com/ipipdotnet/ipdb-go"
|
||
"golang.org/x/text/encoding/simplifiedchinese"
|
||
"golang.org/x/text/transform"
|
||
)
|
||
|
||
//go:embed qqwry.ipdb
|
||
var qqwry []byte
|
||
|
||
func init() {
|
||
LoadData(qqwry)
|
||
|
||
}
|
||
|
||
var (
|
||
data []byte
|
||
dataLen uint32
|
||
ipdbCity *ipdb.City
|
||
dataType = dataTypeDat
|
||
locationCache = &sync.Map{}
|
||
)
|
||
|
||
const (
|
||
dataTypeDat = 0
|
||
dataTypeIpdb = 1
|
||
)
|
||
|
||
const (
|
||
indexLen = 7
|
||
redirectMode1 = 0x01
|
||
redirectMode2 = 0x02
|
||
)
|
||
|
||
type Location struct {
|
||
Country string // 国家
|
||
Province string // 省份
|
||
City string // 城市
|
||
District string // 区县
|
||
ISP string // 运营商
|
||
IP string // IP地址
|
||
}
|
||
|
||
func byte3ToUInt32(data []byte) uint32 {
|
||
i := uint32(data[0]) & 0xff
|
||
i |= (uint32(data[1]) << 8) & 0xff00
|
||
i |= (uint32(data[2]) << 16) & 0xff0000
|
||
return i
|
||
}
|
||
|
||
func gb18030Decode(src []byte) string {
|
||
in := bytes.NewReader(src)
|
||
out := transform.NewReader(in, simplifiedchinese.GB18030.NewDecoder())
|
||
d, _ := io.ReadAll(out)
|
||
return string(d)
|
||
}
|
||
|
||
// QueryIP 从内存或缓存查询IP
|
||
func QueryIP(ip string) (location *Location, err error) {
|
||
if v, ok := locationCache.Load(ip); ok {
|
||
return v.(*Location), nil
|
||
}
|
||
switch dataType {
|
||
case dataTypeDat:
|
||
return QueryIPDat(ip)
|
||
case dataTypeIpdb:
|
||
return QueryIPIpdb(ip)
|
||
default:
|
||
return nil, errors.New("data type not support")
|
||
}
|
||
}
|
||
|
||
// GetIpAddress 获取 IP 归属地和运营商
|
||
func GetIpAddress(ip string) (string, error) {
|
||
html, err := doGet("https://www.ipshudi.com/" + ip + "/")
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
div := getAddress(html, `<td>\n<span>.*</span>\n`)
|
||
div1 := getAddress(html, `<td class="th">运营商</td><td><span>.*</span>`)
|
||
|
||
location := "未知归属地"
|
||
if div != "" {
|
||
location = strings.Split(div, "<span>")[1]
|
||
location = strings.Split(location, "</span>")[0]
|
||
}
|
||
|
||
isp := ""
|
||
if div1 != "" {
|
||
isp = strings.Split(div1, "<span>")[1]
|
||
isp = strings.Split(isp, "</span>")[0]
|
||
}
|
||
|
||
return location + " " + isp, nil
|
||
}
|
||
|
||
// 定义响应数据结构（与 API 返回字段对应）
|
||
type IPLocationResponse struct {
|
||
IP string `json:"ip"`
|
||
IPNumber string `json:"ip_number"`
|
||
IPVersion int `json:"ip_version"`
|
||
CountryName string `json:"country_name"`
|
||
CountryCode2 string `json:"country_code2"`
|
||
ISP string `json:"isp"`
|
||
ResponseCode string `json:"response_code"`
|
||
ResponseMessage string `json:"response_message"`
|
||
}
|
||
|
||
// 调用 IP 定位 API
|
||
func LookupIP(ip string, format string) (*IPLocationResponse, error) {
|
||
// 构建请求 URL
|
||
baseURL := "https://api.iplocation.net/"
|
||
params := url.Values{}
|
||
params.Add("ip", ip)
|
||
if format != "" {
|
||
params.Add("format", format)
|
||
}
|
||
|
||
fullURL := baseURL + "?" + params.Encode()
|
||
|
||
// 发送 GET 请求
|
||
resp, err := http.Get(fullURL)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("请求失败: %v", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
// 读取响应体
|
||
body, err := ioutil.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("读取响应失败: %v", err)
|
||
}
|
||
|
||
// 解析 JSON 响应（默认格式为 json）
|
||
var result IPLocationResponse
|
||
if err := json.Unmarshal(body, &result); err != nil {
|
||
return nil, fmt.Errorf("解析响应失败: %v (响应内容: %s)", err, string(body))
|
||
}
|
||
|
||
// 检查 API 响应状态
|
||
if result.ResponseCode != "200" {
|
||
return nil, fmt.Errorf("API 调用失败: %s (%s)", result.ResponseMessage, result.ResponseCode)
|
||
}
|
||
|
||
return &result, nil
|
||
}
|
||
|
||
// doGet 发送 HTTP GET 请求，返回响应内容
|
||
func doGet(url string) ([]byte, error) {
|
||
resp, err := http.Get(url)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
body, err := ioutil.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return body, nil
|
||
}
|
||
|
||
// getAddress 使用正则表达式从 HTML 中提取内容
|
||
func getAddress(html []byte, pattern string) string {
|
||
re := regexp.MustCompile(pattern)
|
||
return re.FindString(string(html))
|
||
}
|
||
|
||
// 判断IP是否为私有地址（包括IPv4和IPv6）
|
||
func isPrivateIP(ipStr string) (bool, error) {
|
||
ip := net.ParseIP(ipStr)
|
||
if ip == nil {
|
||
return false, fmt.Errorf("无效的IP地址: %s", ipStr)
|
||
}
|
||
|
||
// 定义私有网段
|
||
privateNets := []string{
|
||
// IPv4私有网段
|
||
"10.0.0.0/8",
|
||
"172.16.0.0/12",
|
||
"192.168.0.0/16",
|
||
// IPv6私有网段（ULA和链路本地）
|
||
"fc00::/7",
|
||
"fe80::/10",
|
||
}
|
||
|
||
// 检查IP是否属于任一私有网段
|
||
for _, cidr := range privateNets {
|
||
_, netIP, err := net.ParseCIDR(cidr)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if netIP.Contains(ip) {
|
||
return true, nil
|
||
}
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
// 判断IP是否为环回地址
|
||
func isLoopbackIP(ipStr string) (bool, error) {
|
||
ip := net.ParseIP(ipStr)
|
||
if ip == nil {
|
||
return false, fmt.Errorf("无效的IP地址: %s", ipStr)
|
||
}
|
||
return ip.IsLoopback(), nil
|
||
}
|
||
|
||
// QueryIPDat 从dat查询IP，仅加载dat格式数据库时使用
|
||
func QueryIPDat(ipv4 string) (location *Location, err error) {
|
||
ip := net.ParseIP(ipv4).To4()
|
||
if ip == nil {
|
||
return nil, errors.New("ip is not ipv4")
|
||
}
|
||
|
||
if isLoopback, err := isLoopbackIP(ipv4); isLoopback || err != nil {
|
||
return &Location{ISP: "局域网", IP: ipv4}, nil
|
||
}
|
||
if isPrivateIP, err := isPrivateIP(ipv4); isPrivateIP || err != nil {
|
||
return &Location{ISP: "私有地址", IP: ipv4}, nil
|
||
}
|
||
ip32 := binary.BigEndian.Uint32(ip)
|
||
posA := binary.LittleEndian.Uint32(data[:4])
|
||
posZ := binary.LittleEndian.Uint32(data[4:8])
|
||
var offset uint32 = 0
|
||
for {
|
||
mid := posA + (((posZ-posA)/indexLen)>>1)*indexLen
|
||
// if int(mid+indexLen) > len(data) {
|
||
// return nil, errors.New("ip not found")
|
||
// }
|
||
buf := data[mid : mid+indexLen]
|
||
_ip := binary.LittleEndian.Uint32(buf[:4])
|
||
if posZ-posA == indexLen {
|
||
offset = byte3ToUInt32(buf[4:])
|
||
|
||
buf = data[mid+indexLen : mid+indexLen+indexLen]
|
||
if ip32 < binary.LittleEndian.Uint32(buf[:4]) {
|
||
break
|
||
} else {
|
||
offset = 0
|
||
break
|
||
}
|
||
}
|
||
if _ip > ip32 {
|
||
posZ = mid
|
||
} else if _ip < ip32 {
|
||
posA = mid
|
||
} else if _ip == ip32 {
|
||
offset = byte3ToUInt32(buf[4:])
|
||
break
|
||
}
|
||
}
|
||
if offset <= 0 {
|
||
return nil, errors.New("ip not found")
|
||
}
|
||
posM := offset + 4
|
||
mode := data[posM]
|
||
var ispPos uint32
|
||
var addr, isp string
|
||
switch mode {
|
||
case redirectMode1:
|
||
posC := byte3ToUInt32(data[posM+1 : posM+4])
|
||
mode = data[posC]
|
||
posCA := posC
|
||
if mode == redirectMode2 {
|
||
posCA = byte3ToUInt32(data[posC+1 : posC+4])
|
||
posC += 4
|
||
}
|
||
for i := posCA; i < dataLen; i++ {
|
||
if data[i] == 0 {
|
||
addr = string(data[posCA:i])
|
||
break
|
||
}
|
||
}
|
||
if mode != redirectMode2 {
|
||
posC += uint32(len(addr) + 1)
|
||
}
|
||
ispPos = posC
|
||
case redirectMode2:
|
||
posCA := byte3ToUInt32(data[posM+1 : posM+4])
|
||
for i := posCA; i < dataLen; i++ {
|
||
if data[i] == 0 {
|
||
addr = string(data[posCA:i])
|
||
break
|
||
}
|
||
}
|
||
ispPos = offset + 8
|
||
default:
|
||
posCA := offset + 4
|
||
for i := posCA; i < dataLen; i++ {
|
||
if data[i] == 0 {
|
||
addr = string(data[posCA:i])
|
||
break
|
||
}
|
||
}
|
||
ispPos = offset + uint32(5+len(addr))
|
||
}
|
||
if addr != "" {
|
||
addr = strings.TrimSpace(gb18030Decode([]byte(addr)))
|
||
}
|
||
ispMode := data[ispPos]
|
||
if ispMode == redirectMode1 || ispMode == redirectMode2 {
|
||
ispPos = byte3ToUInt32(data[ispPos+1 : ispPos+4])
|
||
}
|
||
if ispPos > 0 {
|
||
for i := ispPos; i < dataLen; i++ {
|
||
if data[i] == 0 {
|
||
isp = string(data[ispPos:i])
|
||
if isp != "" {
|
||
if strings.Contains(isp, "CZ88.NET") {
|
||
isp = ""
|
||
} else {
|
||
isp = strings.TrimSpace(gb18030Decode([]byte(isp)))
|
||
}
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
location = SplitResult(addr, isp, ipv4)
|
||
locationCache.Store(ipv4, location)
|
||
return location, nil
|
||
}
|
||
|
||
// QueryIPIpdb 从ipdb查询IP，仅加载ipdb格式数据库时使用
|
||
func QueryIPIpdb(ip string) (location *Location, err error) {
|
||
ret, err := ipdbCity.Find(ip, "CN")
|
||
if err != nil {
|
||
return
|
||
}
|
||
location = SplitResult(ret[0], ret[1], ip)
|
||
locationCache.Store(ip, location)
|
||
return location, nil
|
||
}
|
||
|
||
// LoadData 从内存加载IP数据库
|
||
func LoadData(database []byte) {
|
||
if string(database[6:11]) == "build" {
|
||
dataType = dataTypeIpdb
|
||
loadCity, err := ipdb.NewCityFromBytes(database)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
ipdbCity = loadCity
|
||
return
|
||
}
|
||
data = database
|
||
dataLen = uint32(len(data))
|
||
}
|
||
|
||
// LoadFile 从文件加载IP数据库
|
||
func LoadFile(filepath string) (err error) {
|
||
body, err := os.ReadFile(filepath)
|
||
if err != nil {
|
||
return
|
||
}
|
||
LoadData(body)
|
||
return
|
||
}
|
||
|
||
// SplitResult 按照调整后的纯真社区版IP库地理位置格式返回结果
|
||
func SplitResult(addr string, isp string, ipv4 string) (location *Location) {
|
||
location = &Location{ISP: isp, IP: ipv4}
|
||
splitList := strings.Split(addr, "–")
|
||
for i := 0; i < len(splitList); i++ {
|
||
switch i {
|
||
case 0:
|
||
location.Country = splitList[i]
|
||
case 1:
|
||
location.Province = splitList[i]
|
||
case 2:
|
||
location.City = splitList[i]
|
||
case 3:
|
||
location.District = splitList[i]
|
||
}
|
||
}
|
||
if location.Country == "局域网" {
|
||
location.ISP = location.Country
|
||
}
|
||
return
|
||
}
|