parser.go

/*
 * Copyright 2014-2024 Li Kexian
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Go module for domain whois information parsing
 * https://www.likexian.com/
 */

package whoisparser

import (
	"errors"
	"regexp"
	"strings"

	"github.com/likexian/gokit/assert"
	"github.com/likexian/gokit/xslice"
	"golang.org/x/net/idna"
)

// Version returns package version
func Version() string {
	return "1.24.16"
}

// Author returns package author
func Author() string {
	return "[Li Kexian](https://www.likexian.com/)"
}

// License returns package license
func License() string {
	return "Licensed under the Apache License 2.0"
}

// ASNInfo holds ASN information
type ASNInfo struct {
	ASNumber     string
	ASName       string
	ASBlock      string
	Description  string
	AbuseContact string

	ASHandle       string
	RegDate        string
	Updated        string
	Ref            string
	OrgName        string
	OrgId          string
	Address        string
	City           string
	StateProv      string
	PostalCode     string
	Country        string
	OrgTechHandle  string
	OrgTechName    string
	OrgTechPhone   string
	OrgTechEmail   string
	OrgTechRef     string
	OrgAbuseHandle string
	OrgAbuseName   string
	OrgAbusePhone  string
	OrgAbuseEmail  string
	OrgAbuseRef    string

	Uplinks []string
	Peers   []string
}

// Parse returns parsed whois info
func Parse(text string) (whoisInfo WhoisInfo, err error) { //nolint:cyclop
	if err = getDomainErrorType(text); err != nil {
		return
	}

	lt := getLookupType(text)

	var domain = &Domain{}
	if lt == LookupDomain {
		name, extension := searchDomain(text)
		if name == "" {
			err = errors.New("domain name is missing")
			return
		}

		if extension != "" && isExtNotFoundDomain(text, extension) {
			err = ErrNotFoundDomain
			return
		}

		domain.Name, _ = idna.ToASCII(name)
		domain.Extension, _ = idna.ToASCII(extension)
	}

	registrar := &Contact{}
	registrant := &Contact{}
	administrative := &Contact{}
	technical := &Contact{}
	billing := &Contact{}

	whoisText, _ := Prepare(text, domain.Extension)
	whoisLines := strings.Split(whoisText, "\n")

	var asnInfo = &ASNInfo{}

	if lt == LookupASN {
		// very primitive here, nothing fancy
		if strings.Contains(whoisText, "ASNumber") {
			asnInfo = parseARINASN(whoisLines)
		} else if strings.Contains(whoisText, "aut-num") {
			asnInfo = parseASN(whoisLines)
		}
	}

	for i := 0; i < len(whoisLines); i++ {
		line := strings.TrimSpace(whoisLines[i])
		if len(line) < 5 || !strings.Contains(line, ":") {
			continue
		}

		fChar := line[:1]
		if assert.IsContains([]string{"-", "*", "%", ">", ";"}, fChar) {
			continue
		}

		if line[len(line)-1:] == ":" {
			i++
			for ; i < len(whoisLines); i++ {
				thisLine := strings.TrimSpace(whoisLines[i])
				if strings.Contains(thisLine, ":") {
					break
				}
				line += thisLine + ","
			}
			line = strings.Trim(line, ",")
			i--
		}

		lines := strings.SplitN(line, ":", 2)
		name := strings.TrimSpace(lines[0])
		value := strings.TrimSpace(lines[1])
		value = strings.TrimSpace(strings.Trim(value, ":"))

		if value == "" {
			continue
		}

		keyName := searchKeyName(name)
		switch keyName {
		case "domain_id":
			domain.ID = value
		case "domain_name":
			if domain.Domain == "" {
				if firstSpace := strings.IndexByte(value, ' '); firstSpace > 0 {
					value = value[:firstSpace]
				}
				domain.Domain = strings.ToLower(value)
				domain.Punycode, _ = idna.ToASCII(domain.Domain)
			}
		case "domain_status":
			domain.Status = append(domain.Status, strings.Split(value, ",")...)
		case "domain_dnssec":
			if !domain.DNSSec {
				domain.DNSSec = isDNSSecEnabled(value)
			}
		case "whois_server":
			if domain.WhoisServer == "" {
				domain.WhoisServer = value
			}
		case "name_servers":
			domain.NameServers = append(domain.NameServers, strings.Split(value, ",")...)
		case "created_date":
			if domain.CreatedDate == "" {
				domain.CreatedDate = value
				if parsed, err := parseDateString(value); err == nil {
					domain.CreatedDateInTime = &parsed
				}
			}
		case "updated_date":
			if domain.UpdatedDate == "" {
				domain.UpdatedDate = value
				if parsed, err := parseDateString(value); err == nil {
					domain.UpdatedDateInTime = &parsed
				}
			}
		case "expired_date":
			if domain.ExpirationDate == "" {
				domain.ExpirationDate = value
				if parsed, err := parseDateString(value); err == nil {
					domain.ExpirationDateInTime = &parsed
				}
			}
		case "referral_url":
			registrar.ReferralURL = value
		default:
			name = clearKeyName(name)
			if !strings.Contains(name, " ") {
				if name == "registrar" {
					name += " name"
				} else if domain.Extension == "dk" {
					name = "registrant " + name
				} else {
					name += " organization"
				}
			}
			ns := strings.SplitN(name, " ", 2)
			name = strings.TrimSpace("registrant " + ns[1])
			if ns[0] == "registrar" || ns[0] == "registration" {
				parseContact(registrar, name, value)
			} else if ns[0] == "registrant" || ns[0] == "holder" {
				parseContact(registrant, name, value)
			} else if ns[0] == "admin" || ns[0] == "administrative" {
				parseContact(administrative, name, value)
			} else if ns[0] == "tech" || ns[0] == "technical" {
				parseContact(technical, name, value)
			} else if ns[0] == "bill" || ns[0] == "billing" {
				parseContact(billing, name, value)
			}
		}
	}

	domain.NameServers = fixNameServers(domain.NameServers)
	domain.Status = fixDomainStatus(domain.Status)

	domain.NameServers = xslice.Unique(domain.NameServers).([]string)
	domain.Status = xslice.Unique(domain.Status).([]string)

	whoisInfo.Domain = domain
	whoisInfo.ASN = asnInfo

	if *registrar != (Contact{}) {
		whoisInfo.Registrar = registrar
	}

	if *registrant != (Contact{}) {
		whoisInfo.Registrant = registrant
	}

	if *administrative != (Contact{}) {
		whoisInfo.Administrative = administrative
	}

	if *technical != (Contact{}) {
		whoisInfo.Technical = technical
	}

	if *billing != (Contact{}) {
		whoisInfo.Billing = billing
	}

	return
}

// parseContact do parse contact info
func parseContact(contact *Contact, name, value string) {
	switch searchKeyName(name) {
	case "registrant_id":
		contact.ID = value
	case "registrant_name":
		if contact.Name == "" {
			contact.Name = value
		}
	case "registrant_organization":
		if contact.Organization == "" {
			contact.Organization = value
		}
	case "registrant_street":
		if contact.Street == "" {
			contact.Street = value
		} else {
			contact.Street += ", " + value
		}
	case "registrant_city":
		contact.City = value
	case "registrant_state_province":
		contact.Province = value
	case "registrant_postal_code":
		contact.PostalCode = value
	case "registrant_country":
		contact.Country = value
	case "registrant_phone":
		contact.Phone = value
	case "registrant_phone_ext":
		contact.PhoneExt = value
	case "registrant_fax":
		contact.Fax = value
	case "registrant_fax_ext":
		contact.FaxExt = value
	case "registrant_email":
		contact.Email = strings.ToLower(value)
	}
}

// parseASN parses ASN information from whois text
func parseASN(lines []string) *ASNInfo {
	var asnInfo ASNInfo
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if len(line) < 5 || !strings.Contains(line, ":") {
			continue
		}
		parts := strings.SplitN(line, ":", 2)
		key := strings.TrimSpace(parts[0])
		value := strings.TrimSpace(parts[1])

		switch key {
		case "aut-num":
			asnInfo.ASNumber = value
		case "as-name":
			asnInfo.ASName = value
		case "as-block":
			asnInfo.ASBlock = value
		case "descr":
			asnInfo.Description = value
		case "abuse-mailbox":
			asnInfo.AbuseContact = value
		case "import":
			asnInfo.Uplinks = append(asnInfo.Uplinks, value)
		case "export":
			asnInfo.Peers = append(asnInfo.Peers, value)
		}
	}
	return &asnInfo
}

// parseARINASN parses ARIN-style ASN information from whois text
func parseARINASN(lines []string) *ASNInfo {
	var asnInfo ASNInfo
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if len(line) < 5 || !strings.Contains(line, ":") {
			continue
		}
		parts := strings.SplitN(line, ":", 2)
		key := strings.TrimSpace(parts[0])
		value := strings.TrimSpace(parts[1])

		switch key {
		case "ASNumber":
			asnInfo.ASNumber = value
		case "ASName":
			asnInfo.ASName = value
		case "ASHandle":
			asnInfo.ASHandle = value
		case "RegDate":
			asnInfo.RegDate = value
		case "Updated":
			asnInfo.Updated = value
		case "Ref":
			asnInfo.Ref = value
		case "OrgName":
			asnInfo.OrgName = value
		case "OrgId":
			asnInfo.OrgId = value
		case "Address":
			asnInfo.Address = value
		case "City":
			asnInfo.City = value
		case "StateProv":
			asnInfo.StateProv = value
		case "PostalCode":
			asnInfo.PostalCode = value
		case "Country":
			asnInfo.Country = value
		case "OrgTechHandle":
			asnInfo.OrgTechHandle = value
		case "OrgTechName":
			asnInfo.OrgTechName = value
		case "OrgTechPhone":
			asnInfo.OrgTechPhone = value
		case "OrgTechEmail":
			asnInfo.OrgTechEmail = value
		case "OrgTechRef":
			asnInfo.OrgTechRef = value
		case "OrgAbuseHandle":
			asnInfo.OrgAbuseHandle = value
		case "OrgAbuseName":
			asnInfo.OrgAbuseName = value
		case "OrgAbusePhone":
			asnInfo.OrgAbusePhone = value
		case "OrgAbuseEmail":
			asnInfo.OrgAbuseEmail = value
		case "OrgAbuseRef":
			asnInfo.OrgAbuseRef = value
		}
	}
	return &asnInfo
}

var searchDomainRx1 = regexp.MustCompile(`(?i)\[?domain\:?(\s*\_?name)?\]?[\s\.]*\:?` +
	`\s*([^\s\,\;\(\)]+)\.([^\s\,\;\(\)\.]{2,})`)
var searchDomainRx2 = regexp.MustCompile(`(?i)\[?domain\:?(\s*\_?name)?\]?[\s\.]*\:?` +
	`\s*([^\s\,\;\(\)\.]{2,})\n`)

// searchDomain finds domain name and extension from whois information
func searchDomain(text string) (name, extension string) {
	m := searchDomainRx1.FindStringSubmatch(text)
	if len(m) > 0 {
		name = strings.TrimPrefix(strings.TrimSpace(m[2]), "\"")
		extension = strings.TrimSuffix(strings.TrimSpace(m[3]), "\"")
	}

	if name == "" {
		m := searchDomainRx2.FindStringSubmatch(text)
		if len(m) > 0 {
			name = strings.TrimSpace(m[2])
			extension = ""
		}
	}

	if name != "" {
		name = strings.ToLower(name)
		extension = strings.ToLower(extension)
	}

	return
}