From 41f5639530507c6df03702ef41eb8ecf0b1b78f1 Mon Sep 17 00:00:00 2001
From: sblinch <steve.github@blinch.ca>
Date: Wed, 15 Dec 2021 13:48:24 -0800
Subject: [PATCH 1/6] Add support for database types other than MaxMind

---
 reader.go                 | 12 ++++++++++++
 reader_anonymous_ip.go    | 10 +++++++---
 reader_asn.go             | 10 +++++++---
 reader_city.go            | 12 +++++++-----
 reader_connection_type.go | 10 +++++++---
 reader_country.go         | 11 +++++++----
 reader_domain.go          | 10 +++++++---
 reader_isp.go             | 10 +++++++---
 8 files changed, 61 insertions(+), 24 deletions(-)

diff --git a/reader.go b/reader.go
index 918b0bf..b919da6 100644
--- a/reader.go
+++ b/reader.go
@@ -122,3 +122,15 @@ func newReader(buffer []byte) (*reader, error) {
 	}
 	return reader, nil
 }
+
+func isExpectedDatabaseType(databaseType string, expectedTypes ...string) bool {
+	if len(expectedTypes) == 0 {
+		return true
+	}
+	for _, expectedType := range expectedTypes {
+		if databaseType == expectedType {
+			return true
+		}
+	}
+	return false
+}
diff --git a/reader_anonymous_ip.go b/reader_anonymous_ip.go
index 1768aff..8c5dfd9 100644
--- a/reader_anonymous_ip.go
+++ b/reader_anonymous_ip.go
@@ -49,19 +49,23 @@ func (r *AnonymousIPReader) Lookup(ip net.IP) (*AnonymousIP, error) {
 	return result, nil
 }
 
-func NewAnonymousIPReader(buffer []byte) (*AnonymousIPReader, error) {
+func NewAnonymousIPReaderType(buffer []byte, expectedTypes ...string) (*AnonymousIPReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoIP2-Anonymous-IP" {
-		return nil, errors.New("wrong MaxMind DB Anonymous-IP type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database Anonymous-IP type: " + reader.metadata.DatabaseType)
 	}
 	return &AnonymousIPReader{
 		reader: reader,
 	}, nil
 }
 
+func NewAnonymousIPReader(buffer []byte) (*AnonymousIPReader, error) {
+	return NewAnonymousIPReaderType(buffer, "GeoIP2-Anonymous-IP")
+}
+
 func NewAnonymousIPReaderFromFile(filename string) (*AnonymousIPReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {
diff --git a/reader_asn.go b/reader_asn.go
index 44b7470..095de00 100644
--- a/reader_asn.go
+++ b/reader_asn.go
@@ -49,19 +49,23 @@ func (r *ASNReader) Lookup(ip net.IP) (*ASN, error) {
 	return result, nil
 }
 
-func NewASNReader(buffer []byte) (*ASNReader, error) {
+func NewASNReaderType(buffer []byte, expectedTypes ...string) (*ASNReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoLite2-ASN" {
-		return nil, errors.New("wrong MaxMind DB ASN type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database ASN type: " + reader.metadata.DatabaseType)
 	}
 	return &ASNReader{
 		reader: reader,
 	}, nil
 }
 
+func NewASNReader(buffer []byte) (*ASNReader, error) {
+	return NewASNReaderType(buffer, "GeoLite2-ASN")
+}
+
 func NewASNReaderFromFile(filename string) (*ASNReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {
diff --git a/reader_city.go b/reader_city.go
index 6ccd8ce..5b776ca 100644
--- a/reader_city.go
+++ b/reader_city.go
@@ -83,21 +83,23 @@ func (r *CityReader) Lookup(ip net.IP) (*CityResult, error) {
 	return result, nil
 }
 
-func NewCityReader(buffer []byte) (*CityReader, error) {
+func NewCityReaderType(buffer []byte, expectedTypes ...string) (*CityReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoIP2-City" &&
-		reader.metadata.DatabaseType != "GeoLite2-City" &&
-		reader.metadata.DatabaseType != "GeoIP2-Enterprise" {
-		return nil, errors.New("wrong MaxMind DB City type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database City type: " + reader.metadata.DatabaseType)
 	}
 	return &CityReader{
 		reader: reader,
 	}, nil
 }
 
+func NewCityReader(buffer []byte) (*CityReader, error) {
+	return NewCityReaderType(buffer, "GeoIP2-City", "GeoLite2-City", "GeoIP2-Enterprise")
+}
+
 func NewCityReaderFromFile(filename string) (*CityReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {
diff --git a/reader_connection_type.go b/reader_connection_type.go
index cb0e748..f44e522 100644
--- a/reader_connection_type.go
+++ b/reader_connection_type.go
@@ -49,19 +49,23 @@ func (r *ConnectionTypeReader) Lookup(ip net.IP) (string, error) {
 	return result.ConnectionType, nil
 }
 
-func NewConnectionTypeReader(buffer []byte) (*ConnectionTypeReader, error) {
+func NewConnectionTypeReaderType(buffer []byte, expectedTypes ...string) (*ConnectionTypeReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoIP2-Connection-Type" {
-		return nil, errors.New("wrong MaxMind DB Connection-Type type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database Connection-Type type: " + reader.metadata.DatabaseType)
 	}
 	return &ConnectionTypeReader{
 		reader: reader,
 	}, nil
 }
 
+func NewConnectionTypeReader(buffer []byte) (*ConnectionTypeReader, error) {
+	return NewConnectionTypeReaderType(buffer, "GeoIP2-Connection-Type")
+}
+
 func NewConnectionTypeReaderFromFile(filename string) (*ConnectionTypeReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {
diff --git a/reader_country.go b/reader_country.go
index e1e804b..ade8d0f 100644
--- a/reader_country.go
+++ b/reader_country.go
@@ -63,20 +63,23 @@ func (r *CountryReader) Lookup(ip net.IP) (*CountryResult, error) {
 	return result, nil
 }
 
-func NewCountryReader(buffer []byte) (*CountryReader, error) {
+func NewCountryReaderType(buffer []byte, expectedTypes ...string) (*CountryReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoIP2-Country" &&
-		reader.metadata.DatabaseType != "GeoLite2-Country" {
-		return nil, errors.New("wrong MaxMind DB Country type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database Country type: " + reader.metadata.DatabaseType)
 	}
 	return &CountryReader{
 		reader: reader,
 	}, nil
 }
 
+func NewCountryReader(buffer []byte) (*CountryReader, error) {
+	return NewCountryReaderType(buffer, "GeoIP2-Country", "GeoLite2-Country", "Geoacumen-Country")
+}
+
 func NewCountryReaderFromFile(filename string) (*CountryReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {
diff --git a/reader_domain.go b/reader_domain.go
index 12ac07e..ffda259 100644
--- a/reader_domain.go
+++ b/reader_domain.go
@@ -49,19 +49,23 @@ func (r *DomainReader) Lookup(ip net.IP) (string, error) {
 	return result.Domain, nil
 }
 
-func NewDomainReader(buffer []byte) (*DomainReader, error) {
+func NewDomainReaderType(buffer []byte, expectedTypes ...string) (*DomainReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoIP2-Domain" {
-		return nil, errors.New("wrong MaxMind DB Domain type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database Domain type: " + reader.metadata.DatabaseType)
 	}
 	return &DomainReader{
 		reader: reader,
 	}, nil
 }
 
+func NewDomainReader(buffer []byte) (*DomainReader, error) {
+	return NewDomainReaderType(buffer, "GeoIP2-Domain")
+}
+
 func NewDomainReaderFromFile(filename string) (*DomainReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {
diff --git a/reader_isp.go b/reader_isp.go
index 068c13d..398b84f 100644
--- a/reader_isp.go
+++ b/reader_isp.go
@@ -49,19 +49,23 @@ func (r *ISPReader) Lookup(ip net.IP) (*ISP, error) {
 	return result, nil
 }
 
-func NewISPReader(buffer []byte) (*ISPReader, error) {
+func NewISPReaderType(buffer []byte, expectedTypes ...string) (*ISPReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
 	}
-	if reader.metadata.DatabaseType != "GeoIP2-ISP" {
-		return nil, errors.New("wrong MaxMind DB ISP type: " + reader.metadata.DatabaseType)
+	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
+		return nil, errors.New("wrong database ISP type: " + reader.metadata.DatabaseType)
 	}
 	return &ISPReader{
 		reader: reader,
 	}, nil
 }
 
+func NewISPReader(buffer []byte) (*ISPReader, error) {
+	return NewISPReaderType(buffer, "GeoIP2-ISP")
+}
+
 func NewISPReaderFromFile(filename string) (*ISPReader, error) {
 	buffer, err := ioutil.ReadFile(filename)
 	if err != nil {

From 165b188d2ba4f674509488968cff5aa5438a4d3a Mon Sep 17 00:00:00 2001
From: sblinch <steve.github@blinch.ca>
Date: Mon, 20 Dec 2021 23:54:47 -0800
Subject: [PATCH 2/6] Revert removal of MaxMind trademark from error messages

---
 reader_anonymous_ip.go    | 2 +-
 reader_asn.go             | 2 +-
 reader_city.go            | 2 +-
 reader_connection_type.go | 2 +-
 reader_country.go         | 2 +-
 reader_domain.go          | 2 +-
 reader_isp.go             | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/reader_anonymous_ip.go b/reader_anonymous_ip.go
index 8c5dfd9..7d8021b 100644
--- a/reader_anonymous_ip.go
+++ b/reader_anonymous_ip.go
@@ -55,7 +55,7 @@ func NewAnonymousIPReaderType(buffer []byte, expectedTypes ...string) (*Anonymou
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database Anonymous-IP type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB Anonymous-IP type: " + reader.metadata.DatabaseType)
 	}
 	return &AnonymousIPReader{
 		reader: reader,
diff --git a/reader_asn.go b/reader_asn.go
index 095de00..c4789ae 100644
--- a/reader_asn.go
+++ b/reader_asn.go
@@ -55,7 +55,7 @@ func NewASNReaderType(buffer []byte, expectedTypes ...string) (*ASNReader, error
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database ASN type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB ASN type: " + reader.metadata.DatabaseType)
 	}
 	return &ASNReader{
 		reader: reader,
diff --git a/reader_city.go b/reader_city.go
index 5b776ca..7c15ab6 100644
--- a/reader_city.go
+++ b/reader_city.go
@@ -89,7 +89,7 @@ func NewCityReaderType(buffer []byte, expectedTypes ...string) (*CityReader, err
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database City type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB City type: " + reader.metadata.DatabaseType)
 	}
 	return &CityReader{
 		reader: reader,
diff --git a/reader_connection_type.go b/reader_connection_type.go
index f44e522..fa7e0b7 100644
--- a/reader_connection_type.go
+++ b/reader_connection_type.go
@@ -55,7 +55,7 @@ func NewConnectionTypeReaderType(buffer []byte, expectedTypes ...string) (*Conne
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database Connection-Type type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB Connection-Type type: " + reader.metadata.DatabaseType)
 	}
 	return &ConnectionTypeReader{
 		reader: reader,
diff --git a/reader_country.go b/reader_country.go
index ade8d0f..838da06 100644
--- a/reader_country.go
+++ b/reader_country.go
@@ -69,7 +69,7 @@ func NewCountryReaderType(buffer []byte, expectedTypes ...string) (*CountryReade
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database Country type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB Country type: " + reader.metadata.DatabaseType)
 	}
 	return &CountryReader{
 		reader: reader,
diff --git a/reader_domain.go b/reader_domain.go
index ffda259..0645590 100644
--- a/reader_domain.go
+++ b/reader_domain.go
@@ -55,7 +55,7 @@ func NewDomainReaderType(buffer []byte, expectedTypes ...string) (*DomainReader,
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database Domain type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB Domain type: " + reader.metadata.DatabaseType)
 	}
 	return &DomainReader{
 		reader: reader,
diff --git a/reader_isp.go b/reader_isp.go
index 398b84f..565cef7 100644
--- a/reader_isp.go
+++ b/reader_isp.go
@@ -55,7 +55,7 @@ func NewISPReaderType(buffer []byte, expectedTypes ...string) (*ISPReader, error
 		return nil, err
 	}
 	if !isExpectedDatabaseType(reader.metadata.DatabaseType, expectedTypes...) {
-		return nil, errors.New("wrong database ISP type: " + reader.metadata.DatabaseType)
+		return nil, errors.New("wrong MaxMind DB ISP type: " + reader.metadata.DatabaseType)
 	}
 	return &ISPReader{
 		reader: reader,

From e75ca55f3d258b20ee066ff4a9e52388f22482e6 Mon Sep 17 00:00:00 2001
From: sblinch <steve.github@blinch.ca>
Date: Mon, 20 Dec 2021 23:56:48 -0800
Subject: [PATCH 3/6] Rename New*ReaderType functions to New*ReaderWithType

---
 reader_anonymous_ip.go    | 4 ++--
 reader_asn.go             | 4 ++--
 reader_city.go            | 4 ++--
 reader_connection_type.go | 4 ++--
 reader_country.go         | 4 ++--
 reader_domain.go          | 4 ++--
 reader_isp.go             | 4 ++--
 7 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/reader_anonymous_ip.go b/reader_anonymous_ip.go
index 7d8021b..8f4b191 100644
--- a/reader_anonymous_ip.go
+++ b/reader_anonymous_ip.go
@@ -49,7 +49,7 @@ func (r *AnonymousIPReader) Lookup(ip net.IP) (*AnonymousIP, error) {
 	return result, nil
 }
 
-func NewAnonymousIPReaderType(buffer []byte, expectedTypes ...string) (*AnonymousIPReader, error) {
+func NewAnonymousIPReaderWithType(buffer []byte, expectedTypes ...string) (*AnonymousIPReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -63,7 +63,7 @@ func NewAnonymousIPReaderType(buffer []byte, expectedTypes ...string) (*Anonymou
 }
 
 func NewAnonymousIPReader(buffer []byte) (*AnonymousIPReader, error) {
-	return NewAnonymousIPReaderType(buffer, "GeoIP2-Anonymous-IP")
+	return NewAnonymousIPReaderWithType(buffer, "GeoIP2-Anonymous-IP")
 }
 
 func NewAnonymousIPReaderFromFile(filename string) (*AnonymousIPReader, error) {
diff --git a/reader_asn.go b/reader_asn.go
index c4789ae..3554f69 100644
--- a/reader_asn.go
+++ b/reader_asn.go
@@ -49,7 +49,7 @@ func (r *ASNReader) Lookup(ip net.IP) (*ASN, error) {
 	return result, nil
 }
 
-func NewASNReaderType(buffer []byte, expectedTypes ...string) (*ASNReader, error) {
+func NewASNReaderWithType(buffer []byte, expectedTypes ...string) (*ASNReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -63,7 +63,7 @@ func NewASNReaderType(buffer []byte, expectedTypes ...string) (*ASNReader, error
 }
 
 func NewASNReader(buffer []byte) (*ASNReader, error) {
-	return NewASNReaderType(buffer, "GeoLite2-ASN")
+	return NewASNReaderWithType(buffer, "GeoLite2-ASN")
 }
 
 func NewASNReaderFromFile(filename string) (*ASNReader, error) {
diff --git a/reader_city.go b/reader_city.go
index 7c15ab6..0484ecc 100644
--- a/reader_city.go
+++ b/reader_city.go
@@ -83,7 +83,7 @@ func (r *CityReader) Lookup(ip net.IP) (*CityResult, error) {
 	return result, nil
 }
 
-func NewCityReaderType(buffer []byte, expectedTypes ...string) (*CityReader, error) {
+func NewCityReaderWithType(buffer []byte, expectedTypes ...string) (*CityReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -97,7 +97,7 @@ func NewCityReaderType(buffer []byte, expectedTypes ...string) (*CityReader, err
 }
 
 func NewCityReader(buffer []byte) (*CityReader, error) {
-	return NewCityReaderType(buffer, "GeoIP2-City", "GeoLite2-City", "GeoIP2-Enterprise")
+	return NewCityReaderWithType(buffer, "GeoIP2-City", "GeoLite2-City", "GeoIP2-Enterprise")
 }
 
 func NewCityReaderFromFile(filename string) (*CityReader, error) {
diff --git a/reader_connection_type.go b/reader_connection_type.go
index fa7e0b7..af7c942 100644
--- a/reader_connection_type.go
+++ b/reader_connection_type.go
@@ -49,7 +49,7 @@ func (r *ConnectionTypeReader) Lookup(ip net.IP) (string, error) {
 	return result.ConnectionType, nil
 }
 
-func NewConnectionTypeReaderType(buffer []byte, expectedTypes ...string) (*ConnectionTypeReader, error) {
+func NewConnectionTypeReaderWithType(buffer []byte, expectedTypes ...string) (*ConnectionTypeReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -63,7 +63,7 @@ func NewConnectionTypeReaderType(buffer []byte, expectedTypes ...string) (*Conne
 }
 
 func NewConnectionTypeReader(buffer []byte) (*ConnectionTypeReader, error) {
-	return NewConnectionTypeReaderType(buffer, "GeoIP2-Connection-Type")
+	return NewConnectionTypeReaderWithType(buffer, "GeoIP2-Connection-Type")
 }
 
 func NewConnectionTypeReaderFromFile(filename string) (*ConnectionTypeReader, error) {
diff --git a/reader_country.go b/reader_country.go
index 838da06..4cd9b55 100644
--- a/reader_country.go
+++ b/reader_country.go
@@ -63,7 +63,7 @@ func (r *CountryReader) Lookup(ip net.IP) (*CountryResult, error) {
 	return result, nil
 }
 
-func NewCountryReaderType(buffer []byte, expectedTypes ...string) (*CountryReader, error) {
+func NewCountryReaderWithType(buffer []byte, expectedTypes ...string) (*CountryReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -77,7 +77,7 @@ func NewCountryReaderType(buffer []byte, expectedTypes ...string) (*CountryReade
 }
 
 func NewCountryReader(buffer []byte) (*CountryReader, error) {
-	return NewCountryReaderType(buffer, "GeoIP2-Country", "GeoLite2-Country", "Geoacumen-Country")
+	return NewCountryReaderWithType(buffer, "GeoIP2-Country", "GeoLite2-Country", "Geoacumen-Country")
 }
 
 func NewCountryReaderFromFile(filename string) (*CountryReader, error) {
diff --git a/reader_domain.go b/reader_domain.go
index 0645590..e67cbc0 100644
--- a/reader_domain.go
+++ b/reader_domain.go
@@ -49,7 +49,7 @@ func (r *DomainReader) Lookup(ip net.IP) (string, error) {
 	return result.Domain, nil
 }
 
-func NewDomainReaderType(buffer []byte, expectedTypes ...string) (*DomainReader, error) {
+func NewDomainReaderWithType(buffer []byte, expectedTypes ...string) (*DomainReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -63,7 +63,7 @@ func NewDomainReaderType(buffer []byte, expectedTypes ...string) (*DomainReader,
 }
 
 func NewDomainReader(buffer []byte) (*DomainReader, error) {
-	return NewDomainReaderType(buffer, "GeoIP2-Domain")
+	return NewDomainReaderWithType(buffer, "GeoIP2-Domain")
 }
 
 func NewDomainReaderFromFile(filename string) (*DomainReader, error) {
diff --git a/reader_isp.go b/reader_isp.go
index 565cef7..8cffdb7 100644
--- a/reader_isp.go
+++ b/reader_isp.go
@@ -49,7 +49,7 @@ func (r *ISPReader) Lookup(ip net.IP) (*ISP, error) {
 	return result, nil
 }
 
-func NewISPReaderType(buffer []byte, expectedTypes ...string) (*ISPReader, error) {
+func NewISPReaderWithType(buffer []byte, expectedTypes ...string) (*ISPReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
 		return nil, err
@@ -63,7 +63,7 @@ func NewISPReaderType(buffer []byte, expectedTypes ...string) (*ISPReader, error
 }
 
 func NewISPReader(buffer []byte) (*ISPReader, error) {
-	return NewISPReaderType(buffer, "GeoIP2-ISP")
+	return NewISPReaderWithType(buffer, "GeoIP2-ISP")
 }
 
 func NewISPReaderFromFile(filename string) (*ISPReader, error) {

From dff9e7bc7f2ac8e5d24a4666889664aaff67de7a Mon Sep 17 00:00:00 2001
From: sblinch <steve.github@blinch.ca>
Date: Tue, 21 Dec 2021 00:08:47 -0800
Subject: [PATCH 4/6] Add comments to New*ReaderWithType functions explaining
 their "at-own-risk" nature

---
 reader_anonymous_ip.go    | 3 +++
 reader_asn.go             | 3 +++
 reader_city.go            | 3 +++
 reader_connection_type.go | 4 ++++
 reader_country.go         | 3 +++
 reader_domain.go          | 3 +++
 reader_isp.go             | 3 +++
 7 files changed, 22 insertions(+)

diff --git a/reader_anonymous_ip.go b/reader_anonymous_ip.go
index 8f4b191..98927ce 100644
--- a/reader_anonymous_ip.go
+++ b/reader_anonymous_ip.go
@@ -49,6 +49,9 @@ func (r *AnonymousIPReader) Lookup(ip net.IP) (*AnonymousIP, error) {
 	return result, nil
 }
 
+// NewAnonymousIPReaderWithType creates a new AnonymousIPReader that accepts MMDB files with a custom database type.
+// Note that AnonymousIPReader only implements the fields provided by MaxMind GeoIP2-Anonymous-IP databases, and will
+// ignore other fields. It is up to the developer to ensure that the database provides a compatible selection of fields.
 func NewAnonymousIPReaderWithType(buffer []byte, expectedTypes ...string) (*AnonymousIPReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
diff --git a/reader_asn.go b/reader_asn.go
index 3554f69..86c0fab 100644
--- a/reader_asn.go
+++ b/reader_asn.go
@@ -49,6 +49,9 @@ func (r *ASNReader) Lookup(ip net.IP) (*ASN, error) {
 	return result, nil
 }
 
+// NewASNReaderWithType creates a new ASNReader that accepts MMDB files with a custom database type. Note that
+// ASNReader only implements the fields provided by MaxMind GeoLite2-ASN databases, and will ignore other fields.
+// It is up to the developer to ensure that the database provides a compatible selection of fields.
 func NewASNReaderWithType(buffer []byte, expectedTypes ...string) (*ASNReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
diff --git a/reader_city.go b/reader_city.go
index 0484ecc..534adcc 100644
--- a/reader_city.go
+++ b/reader_city.go
@@ -83,6 +83,9 @@ func (r *CityReader) Lookup(ip net.IP) (*CityResult, error) {
 	return result, nil
 }
 
+// NewCityReaderWithType creates a new CityReader that accepts MMDB files with a custom database type. Note that
+// CityReader only implements the fields provided by MaxMind Geo*-City and GeoIP2-Enterprise databases, and will ignore
+// other fields. It is up to the developer to ensure that the database provides a compatible selection of fields.
 func NewCityReaderWithType(buffer []byte, expectedTypes ...string) (*CityReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
diff --git a/reader_connection_type.go b/reader_connection_type.go
index af7c942..9863681 100644
--- a/reader_connection_type.go
+++ b/reader_connection_type.go
@@ -49,6 +49,10 @@ func (r *ConnectionTypeReader) Lookup(ip net.IP) (string, error) {
 	return result.ConnectionType, nil
 }
 
+// NewConnectionTypeReaderWithType creates a new ConnectionTypeReader that accepts MMDB files with a custom database
+// type. Note that ConnectionTypeReader only implements the fields provided by MaxMind GeoIP2-Connection-Type databases,
+// and will ignore other fields. It is up to the developer to ensure that the database provides a compatible selection
+// of fields.
 func NewConnectionTypeReaderWithType(buffer []byte, expectedTypes ...string) (*ConnectionTypeReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
diff --git a/reader_country.go b/reader_country.go
index 4cd9b55..b64558c 100644
--- a/reader_country.go
+++ b/reader_country.go
@@ -63,6 +63,9 @@ func (r *CountryReader) Lookup(ip net.IP) (*CountryResult, error) {
 	return result, nil
 }
 
+// NewCountryReaderWithType creates a new CountryReader that accepts MMDB files with a custom database type. Note that
+// CountryReader only implements the fields provided by MaxMind Geo*-Country databases, and will ignore other fields.
+// It is up to the developer to ensure that the database provides a compatible selection of fields.
 func NewCountryReaderWithType(buffer []byte, expectedTypes ...string) (*CountryReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
diff --git a/reader_domain.go b/reader_domain.go
index e67cbc0..9e0f861 100644
--- a/reader_domain.go
+++ b/reader_domain.go
@@ -49,6 +49,9 @@ func (r *DomainReader) Lookup(ip net.IP) (string, error) {
 	return result.Domain, nil
 }
 
+// NewDomainReaderWithType creates a new DomainReader that accepts MMDB files with a custom database type. Note that
+// DomainReader only implements the fields provided by MaxMind GeoIP2-Domain databases, and will ignore other fields.
+// It is up to the developer to ensure that the database provides a compatible selection of fields.
 func NewDomainReaderWithType(buffer []byte, expectedTypes ...string) (*DomainReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {
diff --git a/reader_isp.go b/reader_isp.go
index 8cffdb7..c069bd4 100644
--- a/reader_isp.go
+++ b/reader_isp.go
@@ -49,6 +49,9 @@ func (r *ISPReader) Lookup(ip net.IP) (*ISP, error) {
 	return result, nil
 }
 
+// NewISPReaderWithType creates a new ISPReader that accepts MMDB files with a custom database type. Note that
+// ISPReader only implements the fields provided by MaxMind GeoIP2-ISP databases, and will ignore other fields.
+// It is up to the developer to ensure that the database provides a compatible selection of fields.
 func NewISPReaderWithType(buffer []byte, expectedTypes ...string) (*ISPReader, error) {
 	reader, err := newReader(buffer)
 	if err != nil {

From 594569a2e2ccbb05abf4ce84599955dfe2c129af Mon Sep 17 00:00:00 2001
From: sblinch <steve.github@blinch.ca>
Date: Tue, 21 Dec 2021 00:21:42 -0800
Subject: [PATCH 5/6] Merge #4 from upstream

---
 .gitignore        | 17 +---------
 README.md         | 31 +++++++++++++++++
 reader_asn.go     |  2 +-
 reader_city.go    |  2 +-
 reader_country.go |  2 +-
 reader_test.go    | 84 ++++++++++++++++++++++++++++++++++++++++++++++-
 6 files changed, 118 insertions(+), 20 deletions(-)

diff --git a/.gitignore b/.gitignore
index 59b9502..d383c56 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,16 +1 @@
-testdata/GeoIP2-City.mmdb
-testdata/GeoIP2-Connection-Type.mmdb
-testdata/GeoIP2-Country.mmdb
-testdata/GeoIP2-ISP.mmdb
-testdata/GeoLite2-ASN.mmdb
-testdata/GeoLite2-City.mmdb
-testdata/GeoLite2-Country.mmdb
-
-testdata/GeoIP2-Anonymous-IP-Test.mmdb
-testdata/GeoIP2-City-Test.mmdb
-testdata/GeoIP2-Connection-Type-Test.mmdb
-testdata/GeoIP2-Country-Test.mmdb
-testdata/GeoIP2-Domain-Test.mmdb
-testdata/GeoIP2-Enterprise-Test.mmdb
-testdata/GeoIP2-ISP-Test.mmdb
-testdata/GeoLite2-ASN-Test.mmdb
+testdata
diff --git a/README.md b/README.md
index d8bda1e..b9adc52 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,37 @@ connection_type-24              3883234     305 ns/op     32 B/op     2 allocs/o
 connection_type_parallel-24    34284831    32.1 ns/op     32 B/op     2 allocs/op
 ```
 
+## Supported databases types
+
+### Country
+- GeoIP2-Country
+- GeoLite2-Country
+- DBIP-Country
+- DBIP-Country-Lite
+
+### City
+- GeoIP2-City
+- GeoLite2-City
+- GeoIP2-Enterprise
+- DBIP-City-Lite
+
+### ISP
+- GeoIP2-ISP
+
+### ASN
+- GeoLite2-ASN
+- DBIP-ASN-Lite
+- DBIP-ASN-Lite (compat=GeoLite2-ASN)
+
+### Connection Type
+- GeoIP2-Connection-Type
+
+### Anonymous IP
+- GeoIP2-Anonymous-IP
+
+### Domain
+- GeoIP2-Domain
+
 ## License
 
 [MIT License](LICENSE).
diff --git a/reader_asn.go b/reader_asn.go
index 86c0fab..b117f12 100644
--- a/reader_asn.go
+++ b/reader_asn.go
@@ -66,7 +66,7 @@ func NewASNReaderWithType(buffer []byte, expectedTypes ...string) (*ASNReader, e
 }
 
 func NewASNReader(buffer []byte) (*ASNReader, error) {
-	return NewASNReaderWithType(buffer, "GeoLite2-ASN")
+	return NewASNReaderWithType(buffer, "GeoLite2-ASN", "DBIP-ASN-Lite", "DBIP-ASN-Lite (compat=GeoLite2-ASN)")
 }
 
 func NewASNReaderFromFile(filename string) (*ASNReader, error) {
diff --git a/reader_city.go b/reader_city.go
index 534adcc..55f764d 100644
--- a/reader_city.go
+++ b/reader_city.go
@@ -100,7 +100,7 @@ func NewCityReaderWithType(buffer []byte, expectedTypes ...string) (*CityReader,
 }
 
 func NewCityReader(buffer []byte) (*CityReader, error) {
-	return NewCityReaderWithType(buffer, "GeoIP2-City", "GeoLite2-City", "GeoIP2-Enterprise")
+	return NewCityReaderWithType(buffer, "GeoIP2-City", "GeoLite2-City", "GeoIP2-Enterprise", "DBIP-City-Lite")
 }
 
 func NewCityReaderFromFile(filename string) (*CityReader, error) {
diff --git a/reader_country.go b/reader_country.go
index b64558c..f0ed3d9 100644
--- a/reader_country.go
+++ b/reader_country.go
@@ -80,7 +80,7 @@ func NewCountryReaderWithType(buffer []byte, expectedTypes ...string) (*CountryR
 }
 
 func NewCountryReader(buffer []byte) (*CountryReader, error) {
-	return NewCountryReaderWithType(buffer, "GeoIP2-Country", "GeoLite2-Country", "Geoacumen-Country")
+	return NewCountryReaderWithType(buffer, "GeoIP2-Country", "GeoLite2-Country", "Geoacumen-Country", "DBIP-Country", "DBIP-Country-Lite")
 }
 
 func NewCountryReaderFromFile(filename string) (*CountryReader, error) {
diff --git a/reader_test.go b/reader_test.go
index 9ed1e4a..9182a2d 100644
--- a/reader_test.go
+++ b/reader_test.go
@@ -1,4 +1,6 @@
-// Test DB https://github.com/maxmind/MaxMind-DB
+// Test DB
+// https://github.com/maxmind/MaxMind-DB
+// https://db-ip.com/db/lite.php
 package geoip2
 
 import (
@@ -406,3 +408,83 @@ func TestASN(t *testing.T) {
 		t.Fatal()
 	}
 }
+
+func TestDBIPCity(t *testing.T) {
+	reader, err := NewCityReaderFromFile("testdata/dbip-city-lite.mmdb")
+	if err != nil {
+		t.Fatal(err)
+	}
+	record, err := reader.Lookup(net.ParseIP("66.30.184.198"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if record.City.GeoNameID != 0 {
+		t.Fatal()
+	}
+	if record.City.Names["en"] != "Boston" {
+		t.Fatal()
+	}
+	if record.Location.Latitude != 42.3601 {
+		t.Fatal()
+	}
+	if record.Location.Longitude != -71.0589 {
+		t.Fatal()
+	}
+	if len(record.Subdivisions) != 1 {
+		t.Fatal()
+	}
+	if record.Subdivisions[0].Names["en"] != "Massachusetts" {
+		t.Fatal()
+	}
+}
+
+func TestDBIPCountry(t *testing.T) {
+	reader, err := NewCountryReaderFromFile("testdata/dbip-country-lite.mmdb")
+	if err != nil {
+		t.Fatal(err)
+	}
+	record, err := reader.Lookup(net.ParseIP("66.30.184.198"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if record.Continent.GeoNameID != 6255149 {
+		t.Fatal()
+	}
+	if record.Continent.Code != "NA" {
+		t.Fatal()
+	}
+	if record.Continent.Names["en"] != "North America" ||
+		record.Continent.Names["ru"] != "Северная Америка" {
+		t.Fatal()
+	}
+	if record.Country.GeoNameID != 6252001 {
+		t.Fatal()
+	}
+	if record.Country.ISOCode != "US" {
+		t.Fatal()
+	}
+	if record.Country.Names["fr"] != "États-Unis" ||
+		record.Country.Names["pt-BR"] != "Estados Unidos" {
+		t.Fatal()
+	}
+	if record.Country.IsInEuropeanUnion {
+		t.Fatal()
+	}
+}
+
+func TestDBIPASN(t *testing.T) {
+	reader, err := NewASNReaderFromFile("testdata/dbip-asn-lite.mmdb")
+	if err != nil {
+		t.Fatal(err)
+	}
+	record, err := reader.Lookup(net.ParseIP("66.30.184.198"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if record.AutonomousSystemNumber != 7922 {
+		t.Fatal()
+	}
+	if record.AutonomousSystemOrganization != "Comcast Cable Communications, LLC" {
+		t.Fatal()
+	}
+}

From 0f60cac97f27cd3384b858447a334a3897f0dafa Mon Sep 17 00:00:00 2001
From: sblinch <steve.github@blinch.ca>
Date: Tue, 21 Dec 2021 00:22:21 -0800
Subject: [PATCH 6/6] Add Geoacumen-Country to README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index b9adc52..5e4c9c9 100644
--- a/README.md
+++ b/README.md
@@ -65,6 +65,7 @@ connection_type_parallel-24    34284831    32.1 ns/op     32 B/op     2 allocs/o
 - GeoLite2-Country
 - DBIP-Country
 - DBIP-Country-Lite
+- Geoacumen-Country
 
 ### City
 - GeoIP2-City