OpenRDAP is an command line [RDAP](https://datatracker.ietf.org/wg/weirds/documents/) client implementation in Go.
[](https://travis-ci.org/openrdap/rdap)
https://www.openrdap.org - homepage
https://www.openrdap.org/demo - live demo
## Features
* Command line RDAP client
* Query types supported:
* ip
* domain
* autnum
* nameserver
* entity
* help
* url
* domain-search
* domain-search-by-nameserver
* domain-search-by-nameserver-ip
* nameserver-search
* nameserver-search-by-ip
* entity-search
* entity-search-by-handle
* Query bootstrapping (automatic RDAP server URL detection for ip/domain/autnum/(experimental) entity queries)
* Bootstrap cache (optional, uses ~/.openrdap by default)
* X.509 client authentication
* Output formats: text, JSON, WHOIS style
* Experimental [object tagging](https://datatracker.ietf.org/doc/draft-ietf-regext-rdap-object-tag/) support
## Installation
This program uses Go. The Go compiler is available from https://golang.org/.
To install:
go install github.com/openrdap/rdap/cmd/rdap@master
This will install the "rdap" binary in your $GOPATH/go/bin directory. Try running:
~/go/bin/rdap google.com
## Usage
| Query type | Usage |
| --- | --- |
| Domain (.com) | rdap -v example.com |
| Network | rdap -v 2001:db8:: |
| Autnum | rdap -v AS15169 |
| Nameserver | rdap -v -t nameserver -s https://rdap.verisign.com/com/v1 ns1.google.com |
| Help | rdap -v -t help -s https://rdap.verisign.com/com/v1 |
| Domain Search | rdap -v -t domain-search -s $SERVER_URL example*.gtld |
| Domain Search (by NS) | rdap -v -t domain-search-by-nameserver -s $SERVER_URL ns1.example.gtld |
| Domain Search (by NS IP) | rdap -v -t domain-search-by-nameserver-ip -s $SERVER_URL 192.0.2.0 |
| Nameserver Search | rdap -v -t nameserver-search -s $SERVER_URL ns1.example.gtld |
| Nameserver Search (by IP) | rdap -v -t nameserver-search-by-ip -s $SERVER_URL 192.0.2.0 |
| Entity Search | rdap -v -t entity-search -s $SERVER_URL ENTITY-TAG |
| Entity Search (by handle) | rdap -v -t entity-search-by-handle -s $SERVER_URL ENTITY-TAG |
See https://www.openrdap.org/docs.
## Go docs
[](https://godoc.org/github.com/openrdap/rdap)
## Uses
Go 1.20+
## Links
- Wikipedia - [Registration Data Access Protocol](https://en.wikipedia.org/wiki/Registration_Data_Access_Protocol)
- [ICANN RDAP pilot](https://www.icann.org/rdap)
- [OpenRDAP](https://www.openrdap.org)
- https://data.iana.org/rdap/ - Official IANA bootstrap information
- https://test.rdap.net/rdap/ - Test alternate bootstrap service with more experimental RDAP servers
- [RFC 7480 HTTP Usage in the Registration Data Access Protocol (RDAP)](https://tools.ietf.org/html/rfc7480)
- [RFC 7481 Security Services for the Registration Data Access Protocol (RDAP)](https://tools.ietf.org/html/rfc7481)
- [RFC 7482 Registration Data Access Protocol (RDAP) Query Format](https://tools.ietf.org/html/rfc7482)
- [RFC 7483 JSON Responses for the Registration Data Access Protocol (RDAP)](https://tools.ietf.org/html/rfc7483)
- [RFC 7484 Finding the Authoritative Registration Data (RDAP) Service](https://tools.ietf.org/html/rfc7484)
rdap-0.9.1/autnum.go 0000664 0000000 0000000 00000001222 14742271423 0014312 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// Autnum represents information of Autonomous System registrations.
//
// Autnum is a topmost RDAP response object.
type Autnum struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
ObjectClassName string
Notices []Notice
Handle string
StartAutnum *uint32
EndAutnum *uint32
IPVersion string `rdap:"ipVersion"`
Name string
Type string
Status []string
Country string
Entities []Entity
Remarks []Remark
Links []Link
Port43 string
Events []Event
}
rdap-0.9.1/bootstrap/ 0000775 0000000 0000000 00000000000 14742271423 0014472 5 ustar 00root root 0000000 0000000 rdap-0.9.1/bootstrap/answer.go 0000664 0000000 0000000 00000001045 14742271423 0016320 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import "net/url"
// Answer represents the result of bootstrapping a single query.
type Answer struct {
// Query looked up in the registry.
//
// This includes any canonicalisation performed to match the Service
// Registry's data format. e.g. lowercasing of domain names, and removal of
// "AS" from AS numbers.
Query string
// Matching service entry. Empty string if no match.
Entry string
// List of RDAP base URLs.
URLs []*url.URL
}
rdap-0.9.1/bootstrap/asn_registry.go 0000664 0000000 0000000 00000006540 14742271423 0017537 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"errors"
"fmt"
"net/url"
"sort"
"strconv"
"strings"
)
type ASNRegistry struct {
// List of ASNs & their RDAP base URLs.
//
// Stored in a sorted order for fast search.
asns []asnRange
file *File
}
// asnRange represents a range of AS numbers and their RDAP base URLs.
//
// Represents a single AS number when MinASN==MaxASN.
type asnRange struct {
MinASN uint32 // First AS number.
MaxASN uint32 // Last AS number.
URLs []*url.URL // RDAP base URLs.
}
// String returns "ASxxxx" for a single AS, or "ASxxxx-ASyyyy" for a range.
func (a asnRange) String() string {
if a.MinASN == a.MaxASN {
return fmt.Sprintf("AS%d", a.MinASN)
}
return fmt.Sprintf("AS%d-AS%d", a.MinASN, a.MaxASN)
}
type asnRangeSorter []asnRange
func (a asnRangeSorter) Len() int {
return len(a)
}
func (a asnRangeSorter) Swap(i int, j int) {
a[i], a[j] = a[j], a[i]
}
func (a asnRangeSorter) Less(i int, j int) bool {
return a[i].MinASN < a[j].MinASN
}
// NewASNRegistry creates an ASNRegistry from an ASN registry JSON document.
//
// The document format is specified in https://tools.ietf.org/html/rfc7484#section-5.3.
func NewASNRegistry(json []byte) (*ASNRegistry, error) {
var registry *File
registry, err := NewFile(json)
if err != nil {
return nil, fmt.Errorf("Error parsing ASN registry: %s\n", err)
}
a := make([]asnRange, 0, len(registry.Entries))
var asn string
var urls []*url.URL
for asn, urls = range registry.Entries {
minASN, maxASN, err := parseASNRange(asn)
if err != nil {
continue
}
a = append(a, asnRange{MinASN: minASN, MaxASN: maxASN, URLs: urls})
}
sort.Sort(asnRangeSorter(a))
return &ASNRegistry{
asns: a,
file: registry,
}, nil
}
// Lookup returns the RDAP base URLs for the AS number question |question|.
//
// Example queries are: "AS1234", "as1234", and "1234".
func (a *ASNRegistry) Lookup(question *Question) (*Answer, error) {
var asn uint32
asn, err := parseASN(question.Query)
if err != nil {
return nil, err
}
index := sort.Search(len(a.asns), func(i int) bool {
return asn <= a.asns[i].MaxASN
})
var entry string
var urls []*url.URL
if index != len(a.asns) && (asn >= a.asns[index].MinASN && asn <= a.asns[index].MaxASN) {
entry = a.asns[index].String()
urls = a.asns[index].URLs
}
return &Answer{
Query: fmt.Sprintf("%d", asn),
Entry: entry,
URLs: urls,
}, nil
}
// File returns a struct describing the registry's JSON document.
func (a *ASNRegistry) File() *File {
return a.file
}
func parseASN(asn string) (uint32, error) {
asn = strings.ToLower(asn)
asn = strings.TrimLeft(asn, "as")
result, err := strconv.ParseUint(asn, 10, 32)
if err != nil {
return 0, err
}
return uint32(result), nil
}
func parseASNRange(asnRange string) (uint32, uint32, error) {
var minASN uint64
var maxASN uint64
var err error
asns := strings.Split(asnRange, "-")
if len(asns) != 1 && len(asns) != 2 {
return 0, 0, errors.New("Malformed ASN range")
}
minASN, err = strconv.ParseUint(asns[0], 10, 32)
if err != nil {
return 0, 0, err
}
if len(asns) == 2 {
maxASN, err = strconv.ParseUint(asns[1], 10, 32)
if err != nil {
return 0, 0, err
}
} else {
maxASN = minASN
}
if minASN > maxASN {
minASN, maxASN = maxASN, minASN
}
return uint32(minASN), uint32(maxASN), nil
}
rdap-0.9.1/bootstrap/asn_registry_test.go 0000664 0000000 0000000 00000001612 14742271423 0020571 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"testing"
"github.com/openrdap/rdap/test"
)
func TestNetRegistryLookupsASN(t *testing.T) {
test.Start(test.Bootstrap)
defer test.Finish()
var bytes []byte = test.Get("https://data.iana.org/rdap/asn.json")
var n *ASNRegistry
n, err := NewASNRegistry(bytes)
if err != nil {
t.Fatal(err)
}
tests := []registryTest{
{
"as287",
false,
"AS287",
[]string{"https://rdap.arin.net/registry", "http://rdap.arin.net/registry"},
},
{
"As1768",
false,
"AS1768-AS1769",
[]string{"https://rdap.apnic.net/"},
},
{
"266652",
false,
"AS265629-AS266652",
[]string{"https://rdap.lacnic.net/rdap/"},
},
{
"not-a-number",
true,
"",
[]string{},
},
{
"999999",
false,
"",
[]string{},
},
}
runRegistryTests(t, tests, n)
}
rdap-0.9.1/bootstrap/cache/ 0000775 0000000 0000000 00000000000 14742271423 0015535 5 ustar 00root root 0000000 0000000 rdap-0.9.1/bootstrap/cache/disk_cache.go 0000664 0000000 0000000 00000007447 14742271423 0020155 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package cache
import (
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"time"
homedir "github.com/mitchellh/go-homedir"
)
const (
defaultCacheDirName = ".openrdap"
)
// A DiskCache caches Service Registry files on disk.
//
// By default they're saved as $HOME/.openrdap/{asn,dns,ipv4,ipv6}.json. File
// mtimes are used to calculate cache expiry.
//
// The cache directory is created automatically as needed.
type DiskCache struct {
// Duration files are stored before they're considered expired.
//
// The default is 24 hours.
Timeout time.Duration
// Directory to store cached files in.
//
// The default is $HOME/.openrdap.
Dir string
lastLoadedModTime map[string]time.Time
}
// NewDiskCache creates a new DiskCache.
func NewDiskCache() *DiskCache {
d := &DiskCache{
lastLoadedModTime: make(map[string]time.Time),
Timeout: time.Hour * 24,
}
dir, err := homedir.Dir()
if err != nil {
panic("Can't determine your home directory")
}
d.Dir = filepath.Join(dir, defaultCacheDirName)
return d
}
// InitDir creates the cache directory if it does not already exist.
//
// Returns true if the directory was created, or false if it already exists/or
// on error.
func (d *DiskCache) InitDir() (bool, error) {
fileInfo, err := os.Stat(d.Dir)
if err == nil {
if fileInfo.IsDir() {
return false, nil
} else {
return false, errors.New("Cache dir is not a dir")
}
}
if os.IsNotExist(err) {
err := os.Mkdir(d.Dir, 0775)
if err == nil {
return true, nil
} else {
return false, err
}
} else {
return false, err
}
}
// SetTimeout sets the duration each Service Registry file can be stored before
// its State() is Expired.
func (d *DiskCache) SetTimeout(timeout time.Duration) {
d.Timeout = timeout
}
// Save saves the file |filename| with |data| to disk.
//
// The cache directory is created if necessary.
func (d *DiskCache) Save(filename string, data []byte) error {
_, err := d.InitDir()
if err != nil {
return err
}
err = ioutil.WriteFile(d.cacheDirPath(filename), data, 0664)
if err != nil {
return err
}
fileModTime, err := d.modTime(filename)
if err == nil {
d.lastLoadedModTime[filename] = fileModTime
} else {
return fmt.Errorf("File %s failed to save correctly: %s", filename, err)
}
return nil
}
// Load loads the file |filename| from disk.
//
// Since Service Registry files do not change much, the file is returned even
// if its State() is Expired.
//
// An error is returned if the file is not on disk.
func (d *DiskCache) Load(filename string) ([]byte, error) {
fileModTime, err := d.modTime(filename)
if err != nil {
return nil, fmt.Errorf("Unable to load %s: %s", filename, err)
}
var bytes []byte
bytes, err = ioutil.ReadFile(d.cacheDirPath(filename))
if err != nil {
return nil, err
}
d.lastLoadedModTime[filename] = fileModTime
return bytes, nil
}
// State returns the cache state of the file |filename|.
//
// The returned state is one of: Absent, Good, ShouldReload, Expired.
func (d *DiskCache) State(filename string) FileState {
var expiry time.Time = time.Now().Add(-d.Timeout)
var state FileState = Absent
fileModTime, err := d.modTime(filename)
if err == nil {
if fileModTime.After(expiry) {
state = ShouldReload
lastLoadedModTime, haveLoaded := d.lastLoadedModTime[filename]
if haveLoaded && !fileModTime.After(lastLoadedModTime) {
state = Good
}
} else {
state = Expired
}
}
return state
}
func (d *DiskCache) modTime(filename string) (time.Time, error) {
var fileInfo os.FileInfo
fileInfo, err := os.Stat(d.cacheDirPath(filename))
if err != nil {
return time.Time{}, err
}
return fileInfo.ModTime(), nil
}
func (d *DiskCache) cacheDirPath(filename string) string {
return filepath.Join(d.Dir, filename)
}
rdap-0.9.1/bootstrap/cache/disk_cache_test.go 0000664 0000000 0000000 00000004471 14742271423 0021206 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package cache
import (
"bytes"
"io/ioutil"
"os"
"path/filepath"
"testing"
"time"
)
func TestDiskCache(t *testing.T) {
dir, err := ioutil.TempDir("", "test")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
rdapDir := filepath.Join(dir, ".openrdap")
m1 := NewDiskCache()
m1.Dir = rdapDir
m2 := NewDiskCache()
m2.Dir = rdapDir
asn1 := []byte(string("file 1"))
asn2 := []byte(string("file 2"))
if m1.State("asn.json") != Absent {
t.Fatalf("asn.json expected absent in m1")
} else if m2.State("asn.json") != Absent {
t.Fatalf("asn.json expected absent in m2")
}
if err := m1.Save("asn.json", asn1); err != nil {
t.Fatalf("Save failed: %s", err)
}
if m1.State("asn.json") != Good {
t.Fatalf("asn.json expected good in m1")
} else if m2.State("asn.json") != ShouldReload {
t.Fatalf("asn.json expected shouldreload in m2")
}
loaded1, err := m1.Load("asn.json")
loaded2, err := m2.Load("asn.json")
if m1.State("asn.json") != Good {
t.Fatalf("asn.json expected good in m1")
} else if m2.State("asn.json") != Good {
t.Fatalf("asn.json expected good in m2")
}
if bytes.Compare(loaded1, asn1) != 0 {
t.Fatalf("loaded1(%v) != asn1(%v)", loaded1, asn1)
} else if bytes.Compare(loaded2, asn1) != 0 {
t.Fatalf("loaded2(%v) != asn1(%v)", loaded2, asn1)
}
time.Sleep(time.Second)
if err := m2.Save("asn.json", asn2); err != nil {
t.Fatalf("Save failed: %s", err)
}
if m1.State("asn.json") != ShouldReload {
t.Fatalf("asn.json expected shouldreload in m1")
} else if m2.State("asn.json") != Good {
t.Fatalf("asn.json expected good in m2")
}
m1.Timeout = 0
m2.Timeout = 0
if m1.State("asn.json") != Expired {
t.Fatal("m1 timeout broken")
} else if m2.State("asn.json") != Expired {
t.Fatal("m2 timeout broken")
}
m1.Timeout = time.Hour
m2.Timeout = time.Hour
loaded1, err = m1.Load("asn.json")
loaded2, err = m2.Load("asn.json")
if m1.State("asn.json") != Good {
t.Fatalf("asn.json expected good in m1")
} else if m2.State("asn.json") != Good {
t.Fatalf("asn.json expected good in m2")
}
if bytes.Compare(loaded1, asn2) != 0 {
t.Fatalf("loaded1(%v) != asn2(%v)", loaded1, asn2)
} else if bytes.Compare(loaded2, asn2) != 0 {
t.Fatalf("loaded2(%v) != asn2(%v)", loaded2, asn2)
}
}
rdap-0.9.1/bootstrap/cache/memory_cache.go 0000664 0000000 0000000 00000003320 14742271423 0020515 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package cache
import (
"fmt"
"time"
)
// A MemoryCache caches Service Registry files in memory.
type MemoryCache struct {
Timeout time.Duration
cache map[string][]byte
mtime map[string]time.Time
}
// NewMemoryCache creates a new MemoryCache.
func NewMemoryCache() *MemoryCache {
return &MemoryCache{
cache: make(map[string][]byte),
mtime: make(map[string]time.Time),
Timeout: time.Hour * 24,
}
}
// SetTimeout sets the duration each Service Registry file can be stored before
// its State() is Expired.
func (m *MemoryCache) SetTimeout(timeout time.Duration) {
m.Timeout = timeout
}
// Save saves the file |filename| with |data| to the cache.
func (m *MemoryCache) Save(filename string, data []byte) error {
m.cache[filename] = make([]byte, len(data))
copy(m.cache[filename], data)
m.mtime[filename] = time.Now()
return nil
}
// Load returns the file |filename| from the cache.
//
// Since Service Registry files do not change much, the file is returned even
// if its State() is Expired.
//
// An error is returned if the file is not in the cache.
func (m *MemoryCache) Load(filename string) ([]byte, error) {
data, ok := m.cache[filename]
if !ok {
return nil, fmt.Errorf("File %s not in cache", filename)
}
result := make([]byte, len(data))
copy(result, data)
return result, nil
}
// State returns the cache state of the file |filename|.
//
// The returned state is one of: Absent, Good, Expired.
func (m *MemoryCache) State(filename string) FileState {
mtime, ok := m.mtime[filename]
if !ok {
return Absent
}
expiry := mtime.Add(m.Timeout)
if expiry.Before(time.Now()) {
return Expired
}
return Good
}
rdap-0.9.1/bootstrap/cache/memory_cache_test.go 0000664 0000000 0000000 00000002106 14742271423 0021555 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package cache
import (
"bytes"
"testing"
"time"
)
func TestMemoryCache(t *testing.T) {
m := NewMemoryCache()
if m.State("not-in-cache.json") != Absent {
t.Fatal("m.State() returned non-Absent for absent file")
}
var data []byte
var err error
data, err = m.Load("not-in-cache.json")
if err == nil {
t.Fatal("Load of not-in-cache.json unexpected result")
}
var testData []byte = []byte("test")
err = m.Save("file.json", testData)
if err != nil {
t.Fatal("Save failed")
}
data, err = m.Load("file.json")
if len(data) == 0 || err != nil || bytes.Compare(data, testData) != 0 {
t.Fatal("Load of file.json unexpected result")
}
testData[0] = 'x'
if data[0] != 't' {
t.Fatalf("Cache doesn't contain a copy, contains %s", data)
}
if m.State("file.json") != Good {
t.Fatal("m.State() returned non-Good for cached file")
}
m.Timeout = 0
time.Sleep(time.Millisecond)
if m.State("file.json") != Expired {
t.Fatal("m.State() returned non-Expired for expired file")
}
}
rdap-0.9.1/bootstrap/cache/registry_cache.go 0000664 0000000 0000000 00000002144 14742271423 0021060 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
// Package cache implements RDAP Service Registry file caching.
//
// There are two separate implementations: MemoryCache and DiskCache.
package cache
import "time"
type FileState int
const (
// File is not in the cache.
Absent FileState = iota
// File is in the cache. The latest version has already accessed (Load or Saved()).
Good
// File is in the cache. A newer version of is available to be Load()'ed.
//
// This is used by DiskCache, which uses a shared cache directory.
ShouldReload
// File is in the cache, but has expired. It still can be Load()'ed.
Expired
)
func (f FileState) String() string {
switch f {
case Absent:
return "not cached"
case Good, ShouldReload:
return "good"
case Expired:
return "expired"
default:
panic("Unknown FileState")
}
}
// A RegistryCache implements a cache of Service Registry files.
type RegistryCache interface {
Load(filename string) ([]byte, error)
Save(filename string, data []byte) error
State(filename string) FileState
SetTimeout(timeout time.Duration)
}
rdap-0.9.1/bootstrap/client.go 0000664 0000000 0000000 00000027077 14742271423 0016314 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
// Package bootstrap implements an RDAP bootstrap client.
//
// All RDAP queries are handled by an RDAP server. To help clients discover
// RDAP servers, IANA publishes Service Registry files
// (https://data.iana.org/rdap) for several query types: Domain names, IP
// addresses, and Autonomous Systems.
//
// Given an RDAP query, this package finds the list of RDAP server URLs which
// can answer it. This includes downloading & parsing the Service Registry
// files.
//
// Basic usage:
// question := &bootstrap.Question{
// RegistryType: bootstrap.DNS,
// Query: "example.cz",
// }
//
// b := &bootstrap.Client{}
//
// var answer *bootstrap.Answer
// answer, err := b.Lookup(question)
//
// if err == nil {
// for _, url := range answer.URLs {
// fmt.Println(url)
// }
// }
//
// Download and list the contents of the DNS Service Registry:
// b := &bootstrap.Client{}
//
// // Before you can use a Registry, you need to download it first.
// err := b.Download(bootstrap.DNS) // Downloads https://data.iana.org/rdap/dns.json.
//
// if err == nil {
// var dns *DNSRegistry = b.DNS()
//
// // Print TLDs with RDAP service.
// for tld, _ := range dns.File().Entries {
// fmt.Println(tld)
// }
// }
//
// You can configure bootstrap.Client{} with a custom http.Client, base URL
// (default https://data.iana.org/rdap), and custom cache. bootstrap.Question{}
// support Contexts (for timeout, etc.).
//
// A bootstrap.Client caches the Service Registry files in memory for both
// performance, and courtesy to data.iana.org. The functions which make network
// requests are:
// - Download() - force download one of Service Registry file.
// - DownloadWithContext() - force download one of Service Registry file.
// - Lookup() - download one Service Registry file if missing, or if the cached file is over (by default) 24 hours old.
//
// Lookup() is intended for repeated usage: A long lived bootstrap.Client will
// download each of {asn,dns,ipv4,ipv6}.json once per 24 hours only, regardless
// of the number of calls made to Lookup(). You can still refresh them manually
// using Download() if required.
//
// By default, Service Registry files are cached in memory. bootstrap.Client
// also supports caching the Service Registry files on disk. The default cache
// location is
// $HOME/.openrdap/.
//
// Disk cache usage:
//
// b := bootstrap.NewClient()
// b.Cache = cache.NewDiskCache()
//
// dsr := b.DNS() // Tries to load dns.json from disk cache, doesn't exist yet, so returns nil.
// b.Download(bootstrap.DNS) // Downloads dns.json, saves to disk cache.
//
// b2 := bootstrap.NewClient()
// b2.Cache = cache.NewDiskCache()
//
// dsr2 := b.DNS() // Loads dns.json from disk cache.
//
// This package also implements the experimental Service Provider registry. Due
// to the experimental nature, no Service Registry file exists on data.iana.org
// yet, additionally the filename isn't known. The current filename used is
// serviceprovider-draft-03.json.
//
// RDAP bootstrapping is defined in https://tools.ietf.org/html/rfc7484.
package bootstrap
import (
"context"
"crypto/sha256"
"encoding/hex"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"time"
"github.com/openrdap/rdap/bootstrap/cache"
)
// A RegistryType represents a bootstrap registry type.
type RegistryType int
const (
DNS RegistryType = iota
IPv4
IPv6
ASN
ServiceProvider
)
func (r RegistryType) String() string {
switch r {
case DNS:
return "dns"
case IPv4:
return "ipv4"
case IPv6:
return "ipv6"
case ASN:
return "asn"
case ServiceProvider:
return "serviceprovider"
default:
panic("Unknown RegistryType")
}
}
const (
// Default URL of the Service Registry files.
DefaultBaseURL = "https://data.iana.org/rdap/"
// Default cache timeout of Service Registries.
DefaultCacheTimeout = time.Hour * 24
)
// Client implements an RDAP bootstrap client.
type Client struct {
HTTP *http.Client // HTTP client.
BaseURL *url.URL // Base URL of the Service Registry files. Default is DefaultBaseURL.
Cache cache.RegistryCache // Service Registry cache. Default is a MemoryCache.
// Optional callback function for verbose messages.
Verbose func(text string)
registries map[RegistryType]Registry
}
// A Registry implements bootstrap lookups.
type Registry interface {
Lookup(question *Question) (*Answer, error)
File() *File
}
func (c *Client) init() {
if c.HTTP == nil {
c.HTTP = &http.Client{}
}
if c.Cache == nil {
c.Cache = cache.NewMemoryCache()
c.Cache.SetTimeout(DefaultCacheTimeout)
}
if c.registries == nil {
c.registries = make(map[RegistryType]Registry)
}
if c.BaseURL == nil {
c.BaseURL, _ = url.Parse(DefaultBaseURL)
}
}
// Download downloads a single bootstrap registry file.
//
// On success, the relevant Registry is refreshed. Use the matching accessor (ASN(), DNS(), IPv4(), or IPv6()) to access it.
func (c *Client) Download(registry RegistryType) error {
return c.DownloadWithContext(context.Background(), registry)
}
// DownloadWithContext downloads a single bootstrap registry file, with context |context|.
//
// On success, the relevant Registry is refreshed. Use the matching accessor (ASN(), DNS(), IPv4(), or IPv6()) to access it.
func (c *Client) DownloadWithContext(ctx context.Context, registry RegistryType) error {
c.init()
var json []byte
var s Registry
json, s, err := c.download(ctx, registry)
if err != nil {
return err
}
err = c.Cache.Save(c.filenameFor(registry), json)
if err != nil {
return err
}
c.registries[registry] = s
return nil
}
func (c *Client) download(ctx context.Context, registry RegistryType) ([]byte, Registry, error) {
u, err := url.Parse(registry.Filename())
if err != nil {
return nil, nil, err
}
baseURL := new(url.URL)
*baseURL = *c.BaseURL
if baseURL.Path != "" && baseURL.Path[len(baseURL.Path)-1] != '/' {
baseURL.Path += "/"
}
var fetchURL *url.URL = baseURL.ResolveReference(u)
req, err := http.NewRequest("GET", fetchURL.String(), nil)
if err != nil {
return nil, nil, err
}
req = req.WithContext(ctx)
resp, err := c.HTTP.Do(req)
if err != nil {
return nil, nil, err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, nil, fmt.Errorf("Server returned non-200 status code: %s", resp.Status)
}
json, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, nil, err
}
var s Registry
s, err = newRegistry(registry, json)
if err != nil {
return json, nil, err
}
return json, s, nil
}
func (c *Client) freshenFromCache(registry RegistryType) {
if c.Cache.State(c.filenameFor(registry)) == cache.ShouldReload {
c.reloadFromCache(registry)
}
}
func (c *Client) reloadFromCache(registry RegistryType) error {
json, err := c.Cache.Load(c.filenameFor(registry))
if err != nil {
return err
}
var s Registry
s, err = newRegistry(registry, json)
if err != nil {
return err
}
c.registries[registry] = s
return nil
}
func newRegistry(registry RegistryType, json []byte) (Registry, error) {
var s Registry
var err error
switch registry {
case ASN:
s, err = NewASNRegistry(json)
case DNS:
s, err = NewDNSRegistry(json)
case IPv4:
s, err = NewNetRegistry(json, 4)
case IPv6:
s, err = NewNetRegistry(json, 6)
case ServiceProvider:
s, err = NewServiceProviderRegistry(json)
default:
panic("Unknown Registrytype")
}
return s, err
}
// Lookup returns the RDAP base URLs for the bootstrap question |question|.
func (c *Client) Lookup(question *Question) (*Answer, error) {
c.init()
if c.Verbose == nil {
c.Verbose = func(text string) {}
}
c.Verbose(" bootstrap: Looking up...")
c.Verbose(fmt.Sprintf(" bootstrap: Question type : %s", question.RegistryType))
c.Verbose(fmt.Sprintf(" bootstrap: Question query: %s", question.Query))
registry := question.RegistryType
var state cache.FileState = c.Cache.State(c.filenameFor(registry))
c.Verbose(fmt.Sprintf(" bootstrap: Cache state: %s: %s", c.filenameFor(registry), state))
var forceDownload bool
if state == cache.ShouldReload {
if err := c.reloadFromCache(registry); err != nil {
forceDownload = true
c.Verbose(fmt.Sprintf(" bootstrap: Cache load error (%s), downloading...", err))
}
}
if c.registries[registry] == nil || forceDownload {
c.Verbose(fmt.Sprintf(" bootstrap: Downloading %s", registry.Filename()))
err := c.DownloadWithContext(question.Context(), registry)
if err != nil {
return nil, err
}
} else {
c.Verbose(" bootstrap: Using cached Service Registry file")
}
answer, err := c.registries[registry].Lookup(question)
if answer != nil {
c.Verbose(fmt.Sprintf(" bootstrap: Looked up '%s'", answer.Query))
if answer.Entry != "" {
c.Verbose(fmt.Sprintf(" bootstrap: Matching entry '%s'", answer.Entry))
} else {
c.Verbose(fmt.Sprintf(" bootstrap: No match"))
}
for i, url := range answer.URLs {
c.Verbose(fmt.Sprintf(" bootstrap: Service URL #%d: '%s'", i+1, url))
}
}
return answer, err
}
// ASN returns the current ASN Registry (or nil if the registry file hasn't been Download()ed).
//
// This function never initiates a network transfer.
func (c *Client) ASN() *ASNRegistry {
c.init()
c.freshenFromCache(ServiceProvider)
s, _ := c.registries[ASN].(*ASNRegistry)
return s
}
//
// DNS returns the current DNS Registry (or nil if the registry file hasn't been Download()ed).
//
// This function never initiates a network transfer.
func (c *Client) DNS() *DNSRegistry {
c.init()
c.freshenFromCache(ServiceProvider)
s, _ := c.registries[DNS].(*DNSRegistry)
return s
}
// IPv4 returns the current IPv4 Registry (or nil if the registry file hasn't been Download()ed).
//
// This function never initiates a network transfer.
func (c *Client) IPv4() *NetRegistry {
c.init()
c.freshenFromCache(ServiceProvider)
s, _ := c.registries[IPv4].(*NetRegistry)
return s
}
// IPv6 returns the current IPv6 Registry (or nil if the registry file hasn't been Download()ed).
//
// This function never initiates a network transfer.
func (c *Client) IPv6() *NetRegistry {
c.init()
c.freshenFromCache(ServiceProvider)
s, _ := c.registries[IPv6].(*NetRegistry)
return s
}
// ServiceProvider returns the current ServiceProvider Registry (or nil if the registry file hasn't been Download()ed).
//
// This function never initiates a network transfer.
func (c *Client) ServiceProvider() *ServiceProviderRegistry {
c.init()
c.freshenFromCache(ServiceProvider)
s, _ := c.registries[ServiceProvider].(*ServiceProviderRegistry)
return s
}
// fileFor returns a filename to save the bootstrap registry file |r| as.
//
// For the official IANA bootstrap service, this is the exact filename, e.g.
// dns.json.
//
// For custom bootstrap services, a 6 character hash of the bootstrap service
// URL is prepended to the filename (e.g. 012def_dns.json), to prevent mixing
// them up.
func (c *Client) filenameFor(r RegistryType) string {
filename := r.Filename()
if c.BaseURL.String() != DefaultBaseURL {
hasher := sha256.New()
hasher.Write([]byte(c.BaseURL.String()))
sha256Hash := hex.EncodeToString(hasher.Sum(nil))
filename = sha256Hash[0:6] + "_" + filename
}
return filename
}
// Filename returns the JSON document filename: One of {asn,dns,ipv4,ipv6,service_provider}.json.
func (r RegistryType) Filename() string {
switch r {
case ASN:
return "asn.json"
case DNS:
return "dns.json"
case IPv4:
return "ipv4.json"
case IPv6:
return "ipv6.json"
case ServiceProvider:
// This is a guess and will need fixing to match whatever IANA chooses.
return "serviceprovider-draft-03.json"
default:
panic("Unknown RegistryType")
}
}
rdap-0.9.1/bootstrap/client_test.go 0000664 0000000 0000000 00000004463 14742271423 0017345 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"net/url"
"testing"
"github.com/openrdap/rdap/test"
)
func TestDownload(t *testing.T) {
test.Start(test.Bootstrap)
defer test.Finish()
c := &Client{}
err := c.Download(DNS)
if err != nil {
t.Fatalf("Download() error: %s", err)
}
if c.ASN() != nil || c.DNS() == nil || c.IPv4() != nil || c.IPv6() != nil {
t.Fatalf("Download() bad")
}
}
func TestLookups(t *testing.T) {
tests := []struct {
Registry RegistryType
Input string
Success bool
URLs []string
}{
{
ASN,
"as1768",
true,
[]string{"https://rdap.apnic.net/"},
},
{
DNS,
"example.br",
true,
[]string{"https://rdap.registro.br/"},
},
{
IPv4,
"41.0.0.0",
true,
[]string{
"https://rdap.afrinic.net/rdap/",
"http://rdap.afrinic.net/rdap/",
},
},
{
IPv6,
"2001:1400::",
true,
[]string{
"https://rdap.db.ripe.net/",
},
},
{
ServiceProvider,
"12345~VRSN",
true,
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
ServiceProvider,
"12345-VRSN",
true,
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
}
test.Start(test.Bootstrap)
test.Start(test.BootstrapExperimental)
defer test.Finish()
c := &Client{}
for _, test := range tests {
var r *Answer
if test.Registry == ServiceProvider {
c.BaseURL, _ = url.Parse("https://test.rdap.net/rdap/")
}
question := &Question{
RegistryType: test.Registry,
Query: test.Input,
}
r, err := c.Lookup(question)
if test.Success != (err == nil) {
t.Errorf("Lookup %s: expected success=%v, got opposite, err=%v", test.Input, test.Success, err)
continue
}
if r == nil {
t.Errorf("Lookup %s: unexpected nil result", test.Input)
continue
}
for i, url := range test.URLs {
if r.URLs[i].String() != url {
t.Errorf("Lookup %s, URL #%d, expected %s, got %s\n", test.Input, i, url, r.URLs[i])
continue
}
}
}
}
func TestLookupWithDownloadError(t *testing.T) {
test.Start(test.BootstrapHTTPError)
defer test.Finish()
c := &Client{}
question := &Question{
RegistryType: DNS,
Query: "example.br",
}
_, err := c.Lookup(question)
if err == nil {
t.Errorf("Unexpected success")
}
t.Logf("Error was: %s", err)
}
rdap-0.9.1/bootstrap/dns_registry.go 0000664 0000000 0000000 00000002777 14742271423 0017552 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"fmt"
"net/url"
"strings"
)
type DNSRegistry struct {
// Map of domain labels (e.g. "br") to RDAP base URLs.
dns map[string][]*url.URL
file *File
}
// NewDNSRegistry creates a DNSRegistry from a DNS registry JSON document.
//
// The document format is specified in https://tools.ietf.org/html/rfc7484#section-4.
func NewDNSRegistry(json []byte) (*DNSRegistry, error) {
var r *File
r, err := NewFile(json)
if err != nil {
return nil, fmt.Errorf("Error parsing DNS bootstrap: %s", err)
}
return &DNSRegistry{
dns: r.Entries,
file: r,
}, nil
}
// Lookup returns the RDAP base URLs for the domain name question |question|.
func (d *DNSRegistry) Lookup(question *Question) (*Answer, error) {
input := question.Query
input = strings.TrimSuffix(input, ".")
input = strings.ToLower(input)
fqdn := input
// Lookup the FQDN.
// e.g. for an.example.com, the following lookups could occur:
// - "an.example.com"
// - "example.com"
// - "com"
// - "" (the root zone)
var urls []*url.URL
for {
var ok bool
urls, ok = d.dns[fqdn]
if ok {
break
} else if fqdn == "" {
break
}
index := strings.IndexByte(fqdn, '.')
if index == -1 {
fqdn = ""
} else {
fqdn = fqdn[index+1:]
}
}
return &Answer{
URLs: urls,
Query: input,
Entry: fqdn,
}, nil
}
// File returns a struct describing the registry's JSON document.
func (d *DNSRegistry) File() *File {
return d.file
}
rdap-0.9.1/bootstrap/dns_registry_test.go 0000664 0000000 0000000 00000003041 14742271423 0020572 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"testing"
"github.com/openrdap/rdap/test"
)
func TestNetRegistryLookupsDNSNested(t *testing.T) {
test.Start(test.BootstrapComplex)
defer test.Finish()
var bytes []byte = test.Get("https://rdap.example.org/dns.json")
var d *DNSRegistry
d, err := NewDNSRegistry(bytes)
if err != nil {
t.Fatal(err)
}
tests := []registryTest{
{
"",
false,
"",
[]string{"https://example.root", "http://example.root"},
},
{
"example.com",
false,
"com",
[]string{"https://example.com", "http://example.com"},
},
{
"sub.example.com",
false,
"sub.example.com",
[]string{"https://example.com/sub", "http://example.com/sub"},
},
{
"sub.sub.example.com",
false,
"sub.example.com",
[]string{"https://example.com/sub", "http://example.com/sub"},
},
{
"example.xyz",
false,
"",
[]string{"https://example.root", "http://example.root"},
},
}
runRegistryTests(t, tests, d)
}
func TestNetRegistryLookupsDNS(t *testing.T) {
test.Start(test.Bootstrap)
defer test.Finish()
var bytes []byte = test.Get("https://data.iana.org/rdap/dns.json")
var d *DNSRegistry
d, err := NewDNSRegistry(bytes)
if err != nil {
t.Fatal(err)
}
tests := []registryTest{
{
"",
false,
"",
[]string{},
},
{
"www.EXAMPLE.BR",
false,
"br",
[]string{"https://rdap.registro.br/"},
},
{
"example.xyz",
false,
"",
[]string{},
},
}
runRegistryTests(t, tests, d)
}
rdap-0.9.1/bootstrap/file.go 0000664 0000000 0000000 00000003035 14742271423 0015741 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"encoding/json"
"errors"
"net/url"
)
// File represents a bootstrap registry file (i.e. {asn,dns,ipv4,ipv6}.json).
type File struct {
// Fields from the JSON document.
Description string
Publication string
Version string
// Map of service entries to RDAP base URLs.
//
// e.g. in ipv6.json, the following mapping:
// "2c00::/12" => https://rdap.afrinic.net/rdap/,
// http://rdap.afrinic.net/rdap/.
Entries map[string][]*url.URL
// The file's JSON document.
JSON []byte
}
// NewFile constructs a File from a bootstrap registry file.
func NewFile(jsonDocument []byte) (*File, error) {
var doc struct {
Description string
Publication string
Version string
Services [][][]string
}
err := json.Unmarshal(jsonDocument, &doc)
if err != nil {
return nil, err
}
f := &File{}
f.Description = doc.Description
f.Publication = doc.Publication
f.Version = doc.Version
f.JSON = jsonDocument
f.Entries = make(map[string][]*url.URL)
for _, s := range doc.Services {
if len(s) != 2 {
return nil, errors.New("Malformed bootstrap (bad services array)")
}
entries := s[0]
rawURLs := s[1]
var urls []*url.URL
for _, rawURL := range rawURLs {
url, err := url.Parse(rawURL)
// Ignore unparsable URLs.
if err != nil {
continue
}
urls = append(urls, url)
}
if len(urls) > 0 {
for _, entry := range entries {
f.Entries[entry] = urls
}
}
}
return f, nil
}
rdap-0.9.1/bootstrap/file_test.go 0000664 0000000 0000000 00000003346 14742271423 0017005 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"testing"
"github.com/openrdap/rdap/test"
)
func TestParseValid(t *testing.T) {
test.Start(test.Bootstrap)
defer test.Finish()
var bytes []byte = test.Get("https://data.iana.org/rdap/dns.json")
var r *File
r, err := NewFile(bytes)
if err != nil {
t.Fatal(err)
}
if len(r.Entries) != 3 {
t.Fatalf("Expected 3 entries, got %d: %v\n", len(r.Entries), r)
}
}
func TestParseEmpty(t *testing.T) {
test.Start(test.BootstrapMalformed)
defer test.Finish()
var bytes []byte = test.Get("https://www.example.org/dns_empty.json")
_, err := NewFile(bytes)
if err == nil {
t.Fatal("Unexpected success parsing empty file")
}
}
func TestParseSyntaxError(t *testing.T) {
test.Start(test.BootstrapMalformed)
defer test.Finish()
var bytes []byte = test.Get("https://www.example.org/dns_syntax_error.json")
_, err := NewFile(bytes)
if err == nil {
t.Fatal("Unexpected success parsing file with syntax error")
}
}
func TestParseBadServices(t *testing.T) {
test.Start(test.BootstrapMalformed)
defer test.Finish()
var bytes []byte = test.Get("https://www.example.org/dns_bad_services.json")
_, err := NewFile(bytes)
if err == nil {
t.Fatal("Unexpected success parsing file with bad services array")
}
}
func TestParseBadURL(t *testing.T) {
test.Start(test.BootstrapMalformed)
defer test.Finish()
var bytes []byte = test.Get("https://www.example.org/dns_bad_url.json")
var r *File
r, err := NewFile(bytes)
if err != nil {
t.Fatal(err)
}
if err != nil {
t.Fatal("Unexpected error parsing file with bad URL")
}
if len(r.Entries) != 3 {
t.Fatalf("Expected 3 entries, got %d: %v\n", len(r.Entries), r)
}
}
rdap-0.9.1/bootstrap/net_registry.go 0000664 0000000 0000000 00000006667 14742271423 0017556 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"bytes"
"errors"
"fmt"
"net"
"net/url"
"sort"
"strings"
)
type NetRegistry struct {
// Map of netmask size (0-32 for IPv4, 0-128 for IPv6) to list of NetEntries.
networks map[int][]netEntry
numIPBytes int // Length in bytes of each IP address (4 for IPv4, 16 for IPv6).
file *File
}
// A netEntry is a network and its RDAP base URLs.
type netEntry struct {
Net *net.IPNet
URLs []*url.URL
}
type netEntrySorter []netEntry
func (a netEntrySorter) Len() int {
return len(a)
}
func (a netEntrySorter) Swap(i int, j int) {
a[i], a[j] = a[j], a[i]
}
func (a netEntrySorter) Less(i int, j int) bool {
return bytes.Compare(a[i].Net.IP, a[j].Net.IP) <= 0
}
// NewNetRegistry creates a NetRegistry from an IPv4 or IPv6 registry JSON document. ipVersion must be 4 or 6.
//
// The document formats are specified in https://tools.ietf.org/html/rfc7484#section-5.1 and https://tools.ietf.org/html/rfc7484#section-5.2.
func NewNetRegistry(json []byte, ipVersion int) (*NetRegistry, error) {
if ipVersion != 4 && ipVersion != 6 {
return nil, fmt.Errorf("Unknown IP version %d", ipVersion)
}
var registry *File
registry, err := NewFile(json)
if err != nil {
return nil, fmt.Errorf("Error parsing net registry file: %s", err)
}
n := &NetRegistry{
networks: map[int][]netEntry{},
numIPBytes: numIPBytesForVersion(ipVersion),
file: registry,
}
var cidr string
var urls []*url.URL
for cidr, urls = range registry.Entries {
_, ipNet, err := net.ParseCIDR(cidr)
if err != nil {
continue
} else if len(ipNet.IP) != n.numIPBytes {
continue
}
size, _ := ipNet.Mask.Size()
n.networks[size] = append(n.networks[size], netEntry{Net: ipNet, URLs: urls})
}
for _, nets := range n.networks {
sort.Sort(netEntrySorter(nets))
}
return n, nil
}
// Lookup returns the RDAP base URLs for the IP address or CIDR range question |Question|.
//
// Example queries are: "192.0.2.0", "192.0.2.0/25". "2001:db8::", "2001::db8::/62".
func (n *NetRegistry) Lookup(question *Question) (*Answer, error) {
input := question.Query
if !strings.ContainsAny(input, "/") {
// Convert IP address to CIDR format, with a /32 or /128 mask.
input = fmt.Sprintf("%s/%d", input, n.numIPBytes*8)
}
_, lookupNet, err := net.ParseCIDR(input)
if err != nil {
return nil, err
}
if len(lookupNet.IP) != n.numIPBytes {
return nil, errors.New("Lookup address has wrong IP protocol")
}
lookupMask, _ := lookupNet.Mask.Size()
var bestEntry string
var bestURLs []*url.URL
var bestMask int
var mask int
var nets []netEntry
for mask, nets = range n.networks {
if mask < bestMask || mask > lookupMask {
continue
}
index := sort.Search(len(nets), func(i int) bool {
net := nets[i].Net
return net.Contains(lookupNet.IP) || bytes.Compare(net.IP, lookupNet.IP) >= 0
})
if index == len(nets) || !nets[index].Net.Contains(lookupNet.IP) {
continue
}
bestEntry = nets[index].Net.String()
bestMask = mask
bestURLs = nets[index].URLs
}
return &Answer{
Query: input,
Entry: bestEntry,
URLs: bestURLs,
}, nil
}
func numIPBytesForVersion(ipVersion int) int {
len := 0
switch ipVersion {
case 4:
len = net.IPv4len
case 6:
len = net.IPv6len
default:
panic("Unknown IP version")
}
return len
}
// File returns a struct describing the registry's JSON document.
func (n *NetRegistry) File() *File {
return n.file
}
rdap-0.9.1/bootstrap/net_registry_test.go 0000664 0000000 0000000 00000003170 14742271423 0020577 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"testing"
"github.com/openrdap/rdap/test"
)
func TestNetRegistryLookupsIPv4(t *testing.T) {
test.Start(test.Bootstrap)
defer test.Finish()
var bytes []byte = test.Get("https://data.iana.org/rdap/ipv4.json")
var n *NetRegistry
n, err := NewNetRegistry(bytes, 4)
if err != nil {
t.Fatal(err)
}
tests := []registryTest{
{
"255.0.0.0",
false,
"",
[]string{},
},
{
"41.0.0.0",
false,
"41.0.0.0/8",
[]string{
"https://rdap.afrinic.net/rdap/",
"http://rdap.afrinic.net/rdap/",
},
},
{
"41.255.255.255",
false,
"41.0.0.0/8",
[]string{
"https://rdap.afrinic.net/rdap/",
"http://rdap.afrinic.net/rdap/",
},
},
{
"41.",
true,
"",
[]string{},
},
}
runRegistryTests(t, tests, n)
}
func TestNetRegistryLookupsIPv6(t *testing.T) {
test.Start(test.Bootstrap)
defer test.Finish()
var bytes []byte = test.Get("https://data.iana.org/rdap/ipv6.json")
var n *NetRegistry
n, err := NewNetRegistry(bytes, 6)
if err != nil {
t.Fatal(err)
}
tests := []registryTest{
{
"4000::",
false,
"",
[]string{},
},
{
"2001:1400::",
false,
"2001:1400::/23",
[]string{
"https://rdap.db.ripe.net/",
},
},
{
"2001:1400::5/128",
false,
"2001:1400::/23",
[]string{
"https://rdap.db.ripe.net/",
},
},
{
"2001:1400::/23",
false,
"2001:1400::/23",
[]string{
"https://rdap.db.ripe.net/",
},
},
{
"2001/129",
true,
"",
[]string{},
},
}
runRegistryTests(t, tests, n)
}
rdap-0.9.1/bootstrap/question.go 0000664 0000000 0000000 00000001475 14742271423 0016677 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import "context"
// Question represents a bootstrap query.
//
// question := &bootstrap.Question{
// RegistryType: bootstrap.DNS,
// Query: "example.cz",
// }
type Question struct {
// Bootstrap registry to query.
RegistryType
// Query text.
Query string
ctx context.Context
}
// WithContext returns a copy of the Question, with context |ctx|.
func (q *Question) WithContext(ctx context.Context) *Question {
q2 := new(Question)
*q2 = *q
q2.ctx = ctx
return q2
}
// Context returns the Question's context.
//
// The returned context is always non-nil; it defaults to the background context.
func (q *Question) Context() context.Context {
if q.ctx == nil {
return context.Background()
}
return q.ctx
}
rdap-0.9.1/bootstrap/service_provider_registry.go 0000664 0000000 0000000 00000003556 14742271423 0022334 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"fmt"
"net/url"
"strings"
)
type ServiceProviderRegistry struct {
// Map of service tag (e.g. "VRSN") to RDAP base URLs.
services map[string][]*url.URL
// The registry's JSON document.
file *File
}
// NewServiceProviderRegistry creates a ServiceProviderRegistry from a Service
// Provider JSON document.
//
// The document format is specified in
// https://datatracker.ietf.org/doc/draft-hollenbeck-regext-rdap-object-tag/.
func NewServiceProviderRegistry(json []byte) (*ServiceProviderRegistry, error) {
var r *File
r, err := NewFile(json)
if err != nil {
return nil, fmt.Errorf("Error parsing Service Provider bootstrap: %s", err)
}
return &ServiceProviderRegistry{
services: r.Entries,
file: r,
}, nil
}
// Lookup returns a list of RDAP base URLs for the entity question |question|.
//
// e.g. for the handle "53774930-VRSN", the RDAP base URLs for "VRSN" are returned.
//
// Missing/malformed/unknown service tags are not treated as errors. An empty
// list of URLs is returned in these cases.
//
// Deprecated: Previously service tags used a TILDE char (e.g. ~VRSN) instead,
// these are still supported.
func (s *ServiceProviderRegistry) Lookup(question *Question) (*Answer, error) {
input := question.Query
// Valid input looks like 12345-VRSN.
offset := strings.LastIndexByte(input, '~')
if offset == -1 {
offset = strings.LastIndexByte(input, '-')
}
if offset == -1 || offset == len(input)-1 {
return &Answer{
Query: input,
}, nil
}
service := input[offset+1:]
urls, ok := s.services[service]
if !ok {
service = ""
}
return &Answer{
URLs: urls,
Query: input,
Entry: service,
}, nil
}
// File returns a struct describing the registry's JSON document.
func (s *ServiceProviderRegistry) File() *File {
return s.file
}
rdap-0.9.1/bootstrap/service_provider_registry_test.go 0000664 0000000 0000000 00000002545 14742271423 0023370 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import (
"testing"
"github.com/openrdap/rdap/test"
)
func TestServiceProviderRegistryLookups(t *testing.T) {
test.Start(test.BootstrapExperimental)
defer test.Finish()
var bytes []byte = test.Get("https://test.rdap.net/rdap/serviceprovider-draft-03.json")
var s *ServiceProviderRegistry
s, err := NewServiceProviderRegistry(bytes)
if err != nil {
t.Fatal(err)
}
tests := []registryTest{
{
"",
false,
"",
[]string{},
},
{
"~",
false,
"",
[]string{},
},
{
"X~VRSN~",
false,
"",
[]string{},
},
{
"12345~VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
"*~VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
"~VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
"12345-VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
"*-VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
"-VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
{
"A-B-VRSN",
false,
"VRSN",
[]string{"https://rdap.verisignlabs.com/rdap/v1"},
},
}
runRegistryTests(t, tests, s)
}
rdap-0.9.1/bootstrap/util_test.go 0000664 0000000 0000000 00000002351 14742271423 0017036 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package bootstrap
import "testing"
type registryTest struct {
Query string
Error bool
Entry string
URLs []string
}
func runRegistryTests(t *testing.T, tests []registryTest, reg Registry) {
for _, test := range tests {
question := &Question{
Query: test.Query,
}
var r *Answer
r, err := reg.Lookup(question)
if test.Error && err == nil {
t.Errorf("Query: %s, expected error, didn't get one\n", test.Query)
continue
} else if !test.Error && err != nil {
t.Errorf("Query: %s, unexpected error: %s\n", test.Query, err)
continue
}
if test.Error {
continue
}
if r == nil {
t.Errorf("Query: %s, unexpected nil Answer, err=%v\n", test.Query, err)
continue
}
if r.Entry != test.Entry {
t.Errorf("Query: %s, expected Entry %s, got %s\n", test.Query, test.Entry, r.Entry)
continue
}
if len(r.URLs) != len(test.URLs) {
t.Errorf("Query: %s, expected %d urls, got %d\n", test.Query, len(test.URLs), len(r.URLs))
continue
}
for i, url := range test.URLs {
if r.URLs[i].String() != url {
t.Errorf("Query %s, URL #%d, expected %s, got %s\n", test.Query, i, url, r.URLs[i])
continue
}
}
}
}
rdap-0.9.1/cli.go 0000664 0000000 0000000 00000040054 14742271423 0013556 0 ustar 00root root 0000000 0000000 package rdap
import (
"bytes"
"context"
"crypto/tls"
"encoding/json"
"encoding/pem"
"fmt"
"io"
"io/ioutil"
"net"
"net/http"
"net/url"
"os"
"strconv"
"strings"
"time"
"github.com/openrdap/rdap/bootstrap"
"github.com/openrdap/rdap/bootstrap/cache"
"github.com/openrdap/rdap/sandbox"
"golang.org/x/crypto/pkcs12"
kingpin "github.com/alecthomas/kingpin/v2"
)
var (
version = "OpenRDAP v0.9.1"
usageText = version + `
(www.openrdap.org)
Usage: rdap [OPTIONS] DOMAIN|IP|ASN|ENTITY|NAMESERVER|RDAP-URL
e.g. rdap example.cz
rdap 192.0.2.0
rdap 2001:db8::
rdap AS2856
rdap https://rdap.nic.cz/domain/example.cz
rdap -f registrant -f administrative -f billing amazon.com.br
rdap --json https://rdap.nic.cz/domain/example.cz
rdap -s https://rdap.nic.cz -t help
Options:
-h, --help Show help message.
-v, --verbose Print verbose messages on STDERR.
-T, --timeout=SECS Timeout after SECS seconds (default: 30).
-k, --insecure Disable SSL certificate verification.
-e, --experimental Enable some experimental options:
- Use the bootstrap service https://test.rdap.net/rdap
- Enable object tag support
Authentication options:
-P, --p12=cert.p12[:password] Use client certificate & private key (PKCS#12 format)
or:
-C, --cert=cert.pem Use client certificate (PEM format)
-K, --key=cert.key Use client private key (PEM format)
Output Options:
--text Output RDAP, plain text "tree" format (default).
-w, --whois Output WHOIS style (domain queries only).
-j, --json Output JSON, pretty-printed format.
-r, --raw Output the raw server response.
Advanced options (query):
-s --server=URL RDAP server to query.
-t --type=TYPE RDAP query type. Normally auto-detected. The types are:
- ip
- domain
- autnum
- nameserver
- entity
- help
- url
- domain-search
- domain-search-by-nameserver
- domain-search-by-nameserver-ip
- nameserver-search
- nameserver-search-by-ip
- entity-search
- entity-search-by-handle
The servers for domain, ip, autnum, url queries can be
determined automatically. Otherwise, the RDAP server
(--server=URL) must be specified.
Advanced options (bootstrapping):
--cache-dir=DIR Bootstrap cache directory to use. Specify empty string
to disable bootstrap caching. The directory is created
automatically as needed. (default: $HOME/.openrdap).
--bs-url=URL Bootstrap service URL (default: https://data.iana.org/rdap)
--bs-ttl=SECS Bootstrap cache time in seconds (default: 3600)
Advanced options (experiments):
--exp=test_rdap_net Use the bootstrap service https://test.rdap.net/rdap
--exp=object_tag Enable object tag support
(draft-hollenbeck-regext-rdap-object-tag)
`
)
const (
experimentalBootstrapURL = "https://test.rdap.net/rdap"
)
// CLIOptions specifies options for the command line client.
type CLIOptions struct {
// Sandbox mode disables the --cache-dir option, to prevent arbitrary writes to
// the file system.
//
// This is used for https://www.openrdap.org/demo.
Sandbox bool
}
// RunCLI runs the OpenRDAP command line client.
//
// |args| are the command line arguments to use (normally os.Args[1:]).
// |stdout| and |stderr| are the io.Writers for STDOUT/STDERR.
// |options| specifies extra options.
//
// Returns the program exit code.
func RunCLI(args []string, stdout io.Writer, stderr io.Writer, options CLIOptions) int {
// For duration timer (in --verbose output).
start := time.Now()
// Setup command line arguments parser.
app := kingpin.New("rdap", "RDAP command-line client")
app.HelpFlag.Short('h')
app.UsageTemplate(usageText)
app.UsageWriter(stdout)
app.ErrorWriter(stderr)
// Instead of letting kingpin call os.Exit(), flag if it requests to exit
// here.
//
// This lets the function be called in libraries/tests without exiting them.
terminate := false
app.Terminate(func(int) {
terminate = true
})
// Command line options.
verboseFlag := app.Flag("verbose", "").Short('v').Bool()
timeoutFlag := app.Flag("timeout", "").Short('T').Default("30").Uint16()
insecureFlag := app.Flag("insecure", "").Short('k').Bool()
queryType := app.Flag("type", "").Short('t').String()
fetchRolesFlag := app.Flag("fetch", "").Short('f').Strings()
serverFlag := app.Flag("server", "").Short('s').String()
experimentalFlag := app.Flag("experimental", "").Short('e').Bool()
experimentsFlag := app.Flag("exp", "").Strings()
cacheDirFlag := app.Flag("cache-dir", "").Default("default").String()
bootstrapURLFlag := app.Flag("bs-url", "").Default("default").String()
bootstrapTimeoutFlag := app.Flag("bs-ttl", "").Default("3600").Uint32()
clientP12FilenameAndPassword := app.Flag("p12", "").Short('P').String()
clientCertFilename := app.Flag("cert", "").Short('C').String()
clientKeyFilename := app.Flag("key", "").Short('K').String()
outputFormatText := app.Flag("text", "").Bool()
outputFormatWhois := app.Flag("whois", "").Short('w').Bool()
outputFormatJSON := app.Flag("json", "").Short('j').Bool()
outputFormatRaw := app.Flag("raw", "").Short('r').Bool()
// Command line query (any remaining non-option arguments).
queryArgs := app.Arg("", "").Strings()
// Parse command line arguments.
// The help messages for -h/--help are printed directly by app.Parse().
_, err := app.Parse(args)
if err != nil {
printError(stderr, fmt.Sprintf("Error: %s\n\n%s", err, usageText))
return 1
} else if terminate {
// Occurs when kingpin prints the --help message.
return 1
}
var verbose func(text string)
if *verboseFlag {
verbose = func(text string) {
fmt.Fprintf(stderr, "# %s\n", text)
}
} else {
verbose = func(text string) {
}
}
verbose(version)
verbose("")
verbose("rdap: Configuring query...")
// Supported experimental options.
experiments := map[string]bool{
"test_rdap_net": false,
"object_tag": false,
"sandbox": false,
}
// Enable experimental options.
for _, e := range *experimentsFlag {
if _, ok := experiments[e]; ok {
experiments[e] = true
verbose(fmt.Sprintf("rdap: Enabled experiment '%s'", e))
} else {
printError(stderr, fmt.Sprintf("Error: unknown experiment '%s'", e))
return 1
}
}
// Enable the -e selection of experiments?
if *experimentalFlag {
verbose("rdap: Enabled -e/--experiments: test_rdap_net, object_tag")
experiments["test_rdap_net"] = true
experiments["object_tag"] = true
}
// Forced sandbox mode?
if experiments["sandbox"] {
options.Sandbox = true
}
// Exactly one argument is required (i.e. the domain/ip/url/etc), unless
// we're making a help query.
if *queryType != "help" && len(*queryArgs) == 0 {
printError(stderr, fmt.Sprintf("Error: %s\n\n%s", "Query object required, e.g. rdap example.cz", usageText))
return 1
}
// Grab the query text.
queryText := ""
if len(*queryArgs) > 0 {
queryText = (*queryArgs)[0]
}
// Construct the request.
var req *Request
switch *queryType {
case "":
req = NewAutoRequest(queryText)
case "help":
req = NewHelpRequest()
case "domain", "dns":
req = NewDomainRequest(queryText)
case "autnum", "as", "asn":
autnum := strings.ToUpper(queryText)
autnum = strings.TrimPrefix(autnum, "AS")
result, err := strconv.ParseUint(autnum, 10, 32)
if err != nil {
printError(stderr, fmt.Sprintf("Invalid ASN '%s'", queryText))
return 1
}
req = NewAutnumRequest(uint32(result))
case "ip":
ip := net.ParseIP(queryText)
if ip == nil {
printError(stderr, fmt.Sprintf("Invalid IP '%s'", queryText))
return 1
}
req = NewIPRequest(ip)
case "nameserver", "ns":
req = NewNameserverRequest(queryText)
case "entity":
req = NewEntityRequest(queryText)
case "url":
fullURL, err := url.Parse(queryText)
if err != nil {
printError(stderr, fmt.Sprintf("Unable to parse URL '%s': %s", queryText, err))
return 1
}
req = NewRawRequest(fullURL)
case "entity-search":
req = NewRequest(EntitySearchRequest, queryText)
case "entity-search-by-handle":
req = NewRequest(EntitySearchByHandleRequest, queryText)
case "domain-search":
req = NewRequest(DomainSearchRequest, queryText)
case "domain-search-by-nameserver":
req = NewRequest(DomainSearchByNameserverRequest, queryText)
case "domain-search-by-nameserver-ip":
req = NewRequest(DomainSearchByNameserverIPRequest, queryText)
case "nameserver-search":
req = NewRequest(NameserverSearchRequest, queryText)
case "nameserver-search-by-ip":
req = NewRequest(NameserverSearchByNameserverIPRequest, queryText)
default:
printError(stderr, fmt.Sprintf("Unknown query type '%s'", *queryType))
return 1
}
// Determine the server.
if req.Server != nil {
if *serverFlag != "" {
printError(stderr, fmt.Sprintf("--server option cannot be used with query type %s", req.Type))
return 1
}
}
// Server URL specified (--server)?
if *serverFlag != "" {
serverURL, err := url.Parse(*serverFlag)
if err != nil {
printError(stderr, fmt.Sprintf("--server error: %s", err))
return 1
}
if serverURL.Scheme == "" {
serverURL.Scheme = "http"
}
req = req.WithServer(serverURL)
verbose(fmt.Sprintf("rdap: Using server '%s'", serverURL))
}
// Custom TLS config.
tlsConfig := &tls.Config{InsecureSkipVerify: *insecureFlag}
bs := &bootstrap.Client{}
// Custom bootstrap cache type/directory?
if *cacheDirFlag == "" {
// Disk cache disabled, use memory cache.
bs.Cache = cache.NewMemoryCache()
verbose("rdap: Using in-memory cache")
} else {
dc := cache.NewDiskCache()
if *cacheDirFlag != "default" {
if !options.Sandbox {
dc.Dir = *cacheDirFlag
} else {
verbose(fmt.Sprintf("rdap: Ignored --cache-dir option (sandbox mode enabled)"))
}
}
verbose(fmt.Sprintf("rdap: Using disk cache (%s)", dc.Dir))
created, err := dc.InitDir()
if created {
verbose(fmt.Sprintf("rdap: Cache dir %s mkdir'ed", dc.Dir))
} else if err != nil {
printError(stderr, fmt.Sprintf("rdap: Error making cache dir %s", dc.Dir))
return 1
}
bs.Cache = dc
}
// Use experimental bootstrap service URL?
if experiments["test_rdap_net"] && *bootstrapURLFlag == "default" {
*bootstrapURLFlag = experimentalBootstrapURL
verbose("rdap: Using test.rdap.net bootstrap service (test_rdap_net experiment)")
}
// Custom bootstrap service URL?
if *bootstrapURLFlag != "default" {
baseURL, err := url.Parse(*bootstrapURLFlag)
if err != nil {
printError(stderr, fmt.Sprintf("Bootstrap URL error: %s", err))
return 1
}
bs.BaseURL = baseURL
verbose(fmt.Sprintf("rdap: Bootstrap URL set to '%s'", baseURL))
} else {
verbose(fmt.Sprintf("rdap: Bootstrap URL is default '%s'", bootstrap.DefaultBaseURL))
}
// Custom bootstrap cache timeout?
if bootstrapTimeoutFlag != nil {
bs.Cache.SetTimeout(time.Duration(*bootstrapTimeoutFlag) * time.Second)
verbose(fmt.Sprintf("rdap: Bootstrap cache TTL set to %d seconds", *bootstrapTimeoutFlag))
}
var clientCert tls.Certificate
if *clientCertFilename != "" || *clientKeyFilename != "" {
if *clientP12FilenameAndPassword != "" {
printError(stderr, fmt.Sprintf("rdap: Error: Can't use both --cert/--key and --p12 together"))
return 1
} else if *clientCertFilename == "" || *clientKeyFilename == "" {
printError(stderr, fmt.Sprintf("rdap: Error: --cert and --key must be used together"))
return 1
} else if options.Sandbox {
verbose(fmt.Sprintf("rdap: Ignored --cert and --key options (sandbox mode enabled)"))
} else {
var err error
clientCert, err = tls.LoadX509KeyPair(*clientCertFilename, *clientKeyFilename)
if err != nil {
printError(stderr, fmt.Sprintf("rdap: Error: cannot load client certificate/key: %s", err))
return 1
}
verbose(fmt.Sprintf("rdap: Loaded client certificate from '%s'", *clientCertFilename))
tlsConfig.Certificates = append(tlsConfig.Certificates, clientCert)
}
} else if *clientP12FilenameAndPassword != "" {
// Split the filename and optional password.
// [0] is the filename, [1] is the optional password.
var p12FilenameAndPassword []string = strings.SplitAfterN(*clientP12FilenameAndPassword, ":", 2)
p12FilenameAndPassword[0] = strings.TrimSuffix(p12FilenameAndPassword[0], ":")
// Use a blank password if none was specified.
if len(p12FilenameAndPassword) == 1 {
p12FilenameAndPassword = append(p12FilenameAndPassword, "")
}
var p12 []byte
var err error
// Load the file from disk, or the sandbox.
if options.Sandbox {
p12, err = sandbox.LoadFile(p12FilenameAndPassword[0])
} else {
p12, err = ioutil.ReadFile(p12FilenameAndPassword[0])
}
// Check the file was read correctly.
if err != nil {
printError(stderr, fmt.Sprintf("rdap: Error: cannot load client certificate: %s", err))
return 1
}
// Convert P12 to PEM blocks.
var blocks []*pem.Block
blocks, err = pkcs12.ToPEM(p12, p12FilenameAndPassword[1])
if err != nil {
printError(stderr, fmt.Sprintf("rdap: Error: cannot read client certificate: %s", err))
return 1
}
// Build single concatenated PEM block.
var pemData []byte
for _, b := range blocks {
pemData = append(pemData, pem.EncodeToMemory(b)...)
}
clientCert, err = tls.X509KeyPair(pemData, pemData)
if err != nil {
printError(stderr, fmt.Sprintf("rdap: Error: cannot read client certificate: %s", err))
return 1
}
verbose(fmt.Sprintf("rdap: Loaded client certificate from '%s'", p12FilenameAndPassword[0]))
tlsConfig.Certificates = append(tlsConfig.Certificates, clientCert)
}
// Custom HTTP client. Used to disable TLS certificate verification.
transport := &http.Transport{
TLSClientConfig: tlsConfig,
}
// Setup http.RoundTripper for http clients
bs.HTTP = &http.Client{
Transport: transport,
}
httpClient := &http.Client{
Transport: transport,
}
client := &Client{
HTTP: httpClient,
Bootstrap: bs,
Verbose: verbose,
UserAgent: version,
ServiceProviderExperiment: experiments["object_tag"],
}
if *insecureFlag {
verbose(fmt.Sprintf("rdap: SSL certificate validation disabled"))
}
// Set the request timeout.
ctx, cancelFunc := context.WithTimeout(context.Background(), time.Duration(*timeoutFlag)*time.Second)
defer cancelFunc()
req = req.WithContext(ctx)
verbose(fmt.Sprintf("rdap: Timeout is %d seconds", *timeoutFlag))
// Run the request.
var resp *Response
resp, err = client.Do(req)
verbose("")
verbose(fmt.Sprintf("rdap: Finished in %s", time.Since(start)))
if err != nil {
printError(stderr, fmt.Sprintf("Error: %s", err))
return 1
}
// Insert a blank line to seperate verbose messages/proper output.
if *verboseFlag {
fmt.Fprintln(stderr, "")
}
// Output formatting.
if !(*outputFormatText || *outputFormatWhois || *outputFormatJSON || *outputFormatRaw) {
*outputFormatText = true
}
// Print the response out in text format?
if *outputFormatText {
printer := &Printer{
Writer: stdout,
BriefLinks: true,
}
printer.Print(resp.Object)
}
// Print the raw response out?
if *outputFormatRaw {
fmt.Printf("%s", resp.HTTP[0].Body)
}
// Print the response, JSON pretty-printed?
if *outputFormatJSON {
var out bytes.Buffer
json.Indent(&out, resp.HTTP[0].Body, "", " ")
out.WriteTo(os.Stdout)
}
// Print WHOIS style response out?
if *outputFormatWhois {
w := resp.ToWhoisStyleResponse()
for _, key := range w.KeyDisplayOrder {
for _, value := range w.Data[key] {
fmt.Fprintf(stdout, "%s: %s\n", key, safePrint(value))
}
}
}
_ = fetchRolesFlag
return 0
}
func safePrint(v string) string {
removeBadChars := func(r rune) rune {
switch {
case r == '\000':
return -1
case r == '\n':
return ' '
default:
return r
}
}
return strings.Map(removeBadChars, v)
}
func printError(stderr io.Writer, text string) {
fmt.Fprintf(stderr, "# %s\n", text)
}
rdap-0.9.1/client.go 0000664 0000000 0000000 00000022434 14742271423 0014267 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"context"
"fmt"
"io/ioutil"
"net/http"
"strings"
"time"
"github.com/openrdap/rdap/bootstrap"
)
// Client implements an RDAP client.
//
// This client executes RDAP requests, and returns the responses as Go values.
//
// Quick usage:
// client := &rdap.Client{}
// domain, err := client.QueryDomain("example.cz")
//
// if err == nil {
// fmt.Printf("Handle=%s Domain=%s\n", domain.Handle, domain.LDHName)
// }
// The QueryDomain(), QueryAutnum(), and QueryIP() methods all provide full contact information, and timeout after 30s.
//
// Normal usage:
// // Query example.cz.
// req := &rdap.Request{
// Type: rdap.DomainRequest,
// Query: "example.cz",
// }
//
// client := &rdap.Client{}
// resp, err := client.Do(req)
//
// if domain, ok := resp.Object.(*rdap.Domain); ok {
// fmt.Printf("Handle=%s Domain=%s\n", domain.Handle, domain.LDHName)
// }
//
// Advanced usage:
//
// This demonstrates custom FetchRoles, a custom Context, a custom HTTP client,
// a custom Bootstrapper, and a custom timeout.
// // Nameserver query on rdap.nic.cz.
// server, _ := url.Parse("https://rdap.nic.cz")
// req := &rdap.Request{
// Type: rdap.NameserverRequest,
// Query: "a.ns.nic.cz",
// FetchRoles: []string{"all"},
// Timeout: time.Second * 45, // Custom timeout.
//
// Server: server,
// }
//
// req = req.WithContext(ctx) // Custom context (see https://blog.golang.org/context).
//
// client := &rdap.Client{}
// client.HTTP = &http.Client{} // Custom HTTP client.
// client.Bootstrap = &bootstrap.Client{} // Custom bootstapper.
//
// resp, err := client.Do(req)
//
// if ns, ok := resp.Object.(*rdap.Nameserver); ok {
// fmt.Printf("Handle=%s Domain=%s\n", ns.Handle, ns.LDHName)
// }
type Client struct {
HTTP *http.Client
Bootstrap *bootstrap.Client
// Optional callback function for verbose messages.
Verbose func(text string)
ServiceProviderExperiment bool
UserAgent string
}
func (c *Client) Do(req *Request) (*Response, error) {
// Response struct.
resp := &Response{}
// Bad query?
if req == nil {
return nil, &ClientError{
Type: InputError,
Text: "nil Request",
}
}
// Init HTTP client?
if c.HTTP == nil {
c.HTTP = &http.Client{}
}
// Init Bootstrap client?
if c.Bootstrap == nil {
c.Bootstrap = &bootstrap.Client{}
}
// Init Verbose callback?
if c.Verbose == nil {
c.Verbose = func(text string) {}
}
c.Verbose("")
c.Verbose(fmt.Sprintf("client: Running..."))
c.Verbose(fmt.Sprintf("client: Request type : %s", req.Type))
c.Verbose(fmt.Sprintf("client: Request query : %s", req.Query))
var reqs []*Request
// Need to bootstrap the query?
if req.Server != nil {
c.Verbose(fmt.Sprintf("client: Request URL : %s", req.URL()))
reqs = []*Request{req}
} else if req.Server == nil {
c.Verbose("client: Request URL : TBD, bootstrap required")
var bootstrapType *bootstrap.RegistryType = bootstrapTypeFor(req)
if bootstrapType == nil || (*bootstrapType == bootstrap.ServiceProvider && !c.ServiceProviderExperiment) {
return nil, &ClientError{
Type: BootstrapNotSupported,
Text: fmt.Sprintf("Cannot run query type '%s' without a server URL, "+
"the server must be specified",
req.Type),
}
}
origBootstrapVerbose := c.Bootstrap.Verbose
c.Bootstrap.Verbose = c.Verbose
defer func() {
c.Bootstrap.Verbose = origBootstrapVerbose
}()
question := &bootstrap.Question{
RegistryType: *bootstrapType,
Query: req.Query,
}
question = question.WithContext(req.Context())
var answer *bootstrap.Answer
var err error
answer, err = c.Bootstrap.Lookup(question)
resp.BootstrapAnswer = answer
if err != nil {
return resp, err
}
// No URLs to query?
if len(answer.URLs) == 0 {
return resp, &ClientError{
Type: BootstrapNoMatch,
Text: fmt.Sprintf("No RDAP servers found for '%s'", question.Query),
}
}
for _, u := range answer.URLs {
reqs = append(reqs, req.WithServer(u))
}
}
for i, r := range reqs {
c.Verbose(fmt.Sprintf("client: RDAP URL #%d is %s", i, r.URL()))
}
for _, r := range reqs {
c.Verbose(fmt.Sprintf("client: GET %s", r.URL()))
httpResponse := c.get(r)
resp.HTTP = append(resp.HTTP, httpResponse)
if httpResponse.Error != nil {
c.Verbose(fmt.Sprintf("client: error: %s",
httpResponse.Error))
if r.Context().Err() == context.DeadlineExceeded {
return resp, httpResponse.Error
}
// Continues to the next RDAP server.
} else {
hrr := httpResponse.Response
c.Verbose(fmt.Sprintf("client: status-code=%d, content-type=%s, length=%d bytes, duration=%s",
hrr.StatusCode,
hrr.Header.Get("Content-Type"),
len(httpResponse.Body),
httpResponse.Duration))
if len(httpResponse.Body) > 0 && hrr.StatusCode >= 200 && hrr.StatusCode <= 299 {
// Decode the response.
decoder := NewDecoder(httpResponse.Body)
resp.Object, httpResponse.Error = decoder.Decode()
if httpResponse.Error != nil {
c.Verbose(fmt.Sprintf("client: Error decoding response: %s",
httpResponse.Error))
continue
}
c.Verbose("client: Successfully decoded response")
// Implement additional fetches here.
return resp, nil
} else if hrr.StatusCode == 404 {
return resp, &ClientError{
Type: ObjectDoesNotExist,
Text: fmt.Sprintf("RDAP server returned 404, object does not exist."),
}
}
}
}
return resp, &ClientError{
Type: NoWorkingServers,
Text: fmt.Sprintf("No RDAP servers responded successfully (tried %d server(s))",
len(reqs)),
}
}
func (c *Client) get(rdapReq *Request) *HTTPResponse {
// HTTPResponse stores the URL, http.Response, response body...
httpResponse := &HTTPResponse{
URL: rdapReq.URL().String(),
}
start := time.Now()
// Setup the HTTP request.
req, err := http.NewRequest("GET", httpResponse.URL, nil)
if err != nil {
httpResponse.Error = err
httpResponse.Duration = time.Since(start)
return httpResponse
}
// Optionally add User-Agent header.
if c.UserAgent != "" {
req.Header.Add("User-Agent", c.UserAgent)
}
// HTTP Accept header.
req.Header.Add("Accept", "application/rdap+json, application/json")
// Add context for timeout.
req = req.WithContext(rdapReq.Context())
// Make the HTTP request.
resp, err := c.HTTP.Do(req)
httpResponse.Response = resp
// Handle errors such as "remote doesn't speak HTTP"...
if err != nil {
httpResponse.Error = err
httpResponse.Duration = time.Since(start)
return httpResponse
}
defer resp.Body.Close()
httpResponse.Body, httpResponse.Error = ioutil.ReadAll(resp.Body)
httpResponse.Duration = time.Since(start)
return httpResponse
}
// QueryDomain makes an RDAP request for the |domain|.
//
// Full contact information (where available) is provided. The timeout is 30s.
func (c *Client) QueryDomain(domain string) (*Domain, error) {
req := &Request{
Type: DomainRequest,
Query: domain,
}
resp, err := c.doQuickRequest(req)
if err != nil {
return nil, err
}
if domain, ok := resp.Object.(*Domain); ok {
return domain, nil
} else if respError, ok := resp.Object.(*Error); ok {
return nil, clientErrorFromRDAPError(respError)
}
return nil, &ClientError{
Type: WrongResponseType,
Text: "The server returned a non-Domain RDAP response",
}
}
func (c *Client) doQuickRequest(req *Request) (*Response, error) {
ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*30)
defer cancelFunc()
req = req.WithContext(ctx)
resp, err := c.Do(req)
return resp, err
}
// QueryAutnum makes an RDAP request for the Autonomous System Number (ASN) |autnum|.
//
// |autnum| is an ASN string, e.g. "AS2856" or "5400".
//
// Full contact information (where available) is provided. The timeout is 30s.
func (c *Client) QueryAutnum(autnum string) (*Autnum, error) {
req := &Request{
Type: AutnumRequest,
Query: autnum,
}
resp, err := c.doQuickRequest(req)
if err != nil {
return nil, err
}
if autnum, ok := resp.Object.(*Autnum); ok {
return autnum, nil
} else if respError, ok := resp.Object.(*Error); ok {
return nil, clientErrorFromRDAPError(respError)
}
return nil, &ClientError{
Type: WrongResponseType,
Text: "The server returned a non-Autnum RDAP response",
}
}
// QueryIP makes an RDAP request for the IPv4/6 address |ip|, e.g. "192.0.2.0" or "2001:db8::".
//
// Full contact information (where available) is provided. The timeout is 30s.
func (c *Client) QueryIP(ip string) (*IPNetwork, error) {
req := &Request{
Type: IPRequest,
Query: ip,
}
resp, err := c.doQuickRequest(req)
if err != nil {
return nil, err
}
if ipNet, ok := resp.Object.(*IPNetwork); ok {
return ipNet, nil
} else if respError, ok := resp.Object.(*Error); ok {
return nil, clientErrorFromRDAPError(respError)
}
return nil, &ClientError{
Type: WrongResponseType,
Text: "The server returned a non-IPNetwork RDAP response",
}
}
func bootstrapTypeFor(req *Request) *bootstrap.RegistryType {
b := new(bootstrap.RegistryType)
switch req.Type {
case DomainRequest:
*b = bootstrap.DNS
case AutnumRequest:
*b = bootstrap.ASN
case EntityRequest:
*b = bootstrap.ServiceProvider
case IPRequest:
if strings.Contains(req.Query, ":") {
*b = bootstrap.IPv6
} else {
*b = bootstrap.IPv4
}
default:
b = nil
}
return b
}
rdap-0.9.1/client_error.go 0000664 0000000 0000000 00000001520 14742271423 0015471 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"fmt"
"strings"
)
type ClientErrorType uint
const (
_ ClientErrorType = iota
InputError
BootstrapNotSupported
BootstrapNoMatch
WrongResponseType
NoWorkingServers
ObjectDoesNotExist
RDAPServerError
)
type ClientError struct {
Type ClientErrorType
Text string
}
func (c ClientError) Error() string {
return c.Text
}
func isClientError(t ClientErrorType, err error) bool {
if ce, ok := err.(*ClientError); ok {
if ce.Type == t {
return true
}
}
return false
}
func clientErrorFromRDAPError(e *Error) *ClientError {
return &ClientError{
Type: RDAPServerError,
Text: fmt.Sprintf("Server returned error code %d, title='%s', description='%s'",
e.ErrorCode,
e.Title,
strings.Join(e.Description, " ")),
}
}
rdap-0.9.1/client_test.go 0000664 0000000 0000000 00000003724 14742271423 0015327 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"fmt"
"testing"
"github.com/openrdap/rdap/test"
)
func verboseFunc() func(text string) {
if testing.Verbose() {
return func(text string) {
fmt.Printf("# %s\n", text)
}
}
return func(text string) {
}
}
func TestClientQueryDomain(t *testing.T) {
test.Start(test.Bootstrap)
test.Start(test.Responses)
defer test.Finish()
client := &Client{
Verbose: verboseFunc(),
}
domain, err := client.QueryDomain("example.cz")
if err != nil {
t.Errorf("Unexpected error: %s", err)
} else if domain == nil {
t.Errorf("Unexpected nil Domain")
} else if domain.LDHName != "example.cz" {
t.Errorf("Unexpected LDHName %s", domain.LDHName)
}
}
func TestClientQueryDomain404(t *testing.T) {
test.Start(test.Bootstrap)
test.Start(test.Responses)
defer test.Finish()
client := &Client{
Verbose: verboseFunc(),
}
_, err := client.QueryDomain("non-existent.cz")
if err == nil {
t.Errorf("Unexpected success")
} else if !isClientError(ObjectDoesNotExist, err) {
t.Errorf("Unexpected err %s", err)
}
}
func TestClientQueryDomainWrongType(t *testing.T) {
test.Start(test.Bootstrap)
test.Start(test.Responses)
defer test.Finish()
client := &Client{
Verbose: verboseFunc(),
}
_, err := client.QueryDomain("wrong-response-type.cz")
if err == nil {
t.Errorf("Unexpected success")
} else if !isClientError(WrongResponseType, err) {
t.Errorf("Unexpected err %s", err)
}
}
func TestClientQueryDomainMalformed(t *testing.T) {
test.Start(test.Bootstrap)
test.Start(test.Responses)
defer test.Finish()
client := &Client{
Verbose: verboseFunc(),
}
_, err := client.QueryDomain("malformed.cz")
if err == nil {
t.Errorf("Unexpected success")
} else if !isClientError(NoWorkingServers, err) {
t.Errorf("Unexpected err %s", err)
}
}
// test Do()
// 1) success, 1 of each query
// 2) bootstrap not supported
// 3) bootstrap no match
// test Help...
rdap-0.9.1/cmd/ 0000775 0000000 0000000 00000000000 14742271423 0013220 5 ustar 00root root 0000000 0000000 rdap-0.9.1/cmd/rdap/ 0000775 0000000 0000000 00000000000 14742271423 0014146 5 ustar 00root root 0000000 0000000 rdap-0.9.1/cmd/rdap/main.go 0000664 0000000 0000000 00000000260 14742271423 0015417 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/openrdap/rdap"
)
func main() {
exitCode := rdap.RunCLI(os.Args[1:], os.Stdout, os.Stderr, rdap.CLIOptions{})
os.Exit(exitCode)
}
rdap-0.9.1/common.go 0000664 0000000 0000000 00000004424 14742271423 0014300 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// RDAP Conformance
// Appears in topmost JSON objects only, embedded (no separate type):
// Conformance []string `rdap:"rdapConformance"`
//
// https://tools.ietf.org/html/rfc7483#section-4.1
// Link signifies a link another resource on the Internet.
//
// https://tools.ietf.org/html/rfc7483#section-4.2
type Link struct {
DecodeData *DecodeData
Value string
Rel string
Href string
HrefLang []string `rdap:"hreflang"`
Title string
Media string
Type string
}
// Notice contains information about the entire RDAP response.
//
// https://tools.ietf.org/html/rfc7483#section-4.3
type Notice struct {
DecodeData *DecodeData
Title string
Type string
Description []string
Links []Link
}
// Remark contains information about the containing RDAP object.
//
// https://tools.ietf.org/html/rfc7483#section-4.3
type Remark struct {
DecodeData *DecodeData
Title string
Type string
Description []string
Links []Link
}
// Language Identifier
// Appears in anywhere, embedded (no separate type):
// Lang string
//
// https://tools.ietf.org/html/rfc7483#section-4.4
// Event represents some event which has occured/may occur in the future..
//
// https://tools.ietf.org/html/rfc7483#section-4.5
type Event struct {
DecodeData *DecodeData
Action string `rdap:"eventAction"`
Actor string `rdap:"eventActor"`
Date string `rdap:"eventDate"`
Links []Link
}
// Status indicates the state of a registered object.
// Embedded (no separate type):
// Status []string
//
// https://tools.ietf.org/html/rfc7483#section-4.6
// Port43 indicates the IP/FQDN of a WHOIS server.
// Embedded (no separate type):
// Port43 string
//
// https://tools.ietf.org/html/rfc7483#section-4.7
// PublicID maps a public identifier to an object class.
//
// https://tools.ietf.org/html/rfc7483#section-4.8
type PublicID struct {
DecodeData *DecodeData
Type string
Identifier string
}
// ObjectClassName specifies the object type as a string.
// Embedded (no separate type):
// ObjectClassName string
//
// https://tools.ietf.org/html/rfc7483#section-4.9
// Common contains fields which may appear anywhere in an RDAP response.
type Common struct {
Lang string
}
rdap-0.9.1/decode_data.go 0000664 0000000 0000000 00000005413 14742271423 0015223 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// DecodeData stores a snapshot of all fields in an RDAP object (in raw
// interface{} form), at the time of decoding. This allows the values of unknown
// fields to be retrieved.
//
// DecodeData also stores minor warnings/errors generated during decoding.
//
// DecodeData appears in each RDAP struct (e.g. rdap.Domain{}), and is populated
// during decoding. For manually constructed RDAP structs (d :=
// &rdap.Domain{Handle: "x"}...), DecodeData is not relevant and can be ignored.
//
// The snapshot values are entirely independent from other fields, and thus are
// not synchronised in any way.
type DecodeData struct {
isKnown map[string]bool
values map[string]interface{}
overrideKnownValue map[string]bool
notes map[string][]string
}
// TODO (temporary, using for spew output)
func (r DecodeData) String() string {
result := "["
for name, notes := range r.notes {
for _, note := range notes {
result += "\n !!!" + name + ": " + note
}
}
result += "\n"
return result
}
// Notes returns a list of minor warnings/errors encountered while decoding the
// field |name|.
//
// |name| is the RDAP field name (not the Go field name), so "port43", not
// "Port43". For a full list of decoded field names, use Fields().
//
// The warnings/errors returned look like: "invalid JSON type, expecting float".
func (r DecodeData) Notes(name string) []string {
if notes, ok := r.notes[name]; ok {
return notes
}
return nil
}
//func (r DecodeData) OverrideValue(key string, value interface{}) {
// r.values[key] = value
// r.overrideKnownValue[key] = true
//}
// Value returns the value of the field |name| as an interface{}.
//
// |name| is the RDAP field name (not the Go field name), so "port43", not
// "Port43". For a full list of decoded field names, use Fields().
//
func (r DecodeData) Value(name string) interface{} {
if v, ok := r.values[name]; ok {
return v
}
return nil
}
// Fields returns a list of all RDAP field names decoded.
//
// This includes both known/unknown fields.
//
// The names returned are the RDAP field names (not the Go field names), so
// "port43", not "Port43".
func (r DecodeData) Fields() []string {
var fields []string
for f := range r.values {
fields = append(fields, f)
}
return fields
}
// UnknownFields returns a list of unknown RDAP fields decoded.
func (r DecodeData) UnknownFields() []string {
var fields []string
for f := range r.values {
if _, isKnown := r.isKnown[f]; !isKnown {
fields = append(fields, f)
}
}
return fields
}
func (r *DecodeData) init() {
r.isKnown = map[string]bool{}
r.values = map[string]interface{}{}
r.overrideKnownValue = map[string]bool{}
r.notes = map[string][]string{}
}
rdap-0.9.1/decoder.go 0000664 0000000 0000000 00000052104 14742271423 0014413 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"encoding/json"
"math"
"reflect"
"strconv"
"strings"
)
// Decoder decodes an RDAP response (https://tools.ietf.org/html/rfc7483) into a Go value.
//
// An RDAP response describes an object such as a Domain (data resembling "whois
// example.com"), or an IP Network (data resembling "whois 2001:db8::"). For a
// live example, see https://rdap.nic.cz/domain/ctk.cz.
//
// To decode an RDAP response:
//
// jsonBlob := []byte(`
// {
// "objectClassName": "domain",
// "rdapConformance": ["rdap_level_0"],
// "handle": "EXAMPLECOM",
// "ldhName": "example.com",
// "entities": []
// }
// `)
//
// d := rdap.NewDecoder(jsonBlob)
// result, err := d.Decode()
//
// if err != nil {
// if domain, ok := result.(*rdap.Domain); ok {
// fmt.Printf("Domain name = %s\n", domain.LDHName)
// }
// }
//
// RDAP responses are decoded into the following types:
// &rdap.Error{} - Responses with an errorCode value.
// &rdap.Autnum{} - Responses with objectClassName="autnum".
// &rdap.Domain{} - Responses with objectClassName="domain".
// &rdap.Entity{} - Responses with objectClassName="entity".
// &rdap.IPNetwork{} - Responses with objectClassName="ip network".
// &rdap.Nameserver{} - Responses with objectClassName="nameserver".
// &rdap.DomainSearchResults{} - Responses with a domainSearchResults array.
// &rdap.EntitySearchResults{} - Responses with a entitySearchResults array.
// &rdap.NameserverSearchResults{} - Responses with a nameserverSearchResults array.
// &rdap.Help{} - All other valid JSON responses.
//
// Note that an RDAP server may return a different response type than expected.
//
// The decoder supports and stores unknown RDAP fields. See the DecodeData
// documentation for accessing them.
//
// Decoding is performed on a best-effort basis, with "minor error"s ignored.
// This avoids minor errors rendering a response undecodable.
type Decoder struct {
data []byte
target interface{}
}
// DecoderOption sets a Decoder option.
type DecoderOption func(*Decoder)
// DecoderError represents a fatal error encountered while decoding.
type DecoderError struct {
text string
}
func (d DecoderError) Error() string {
return d.text
}
// NewDecoder creates a new Decoder to decode the RDAP response |jsonBlob|.
//
// |opts| is an optional list of DecoderOptions.
func NewDecoder(jsonBlob []byte, opts ...DecoderOption) *Decoder {
d := &Decoder{
data: jsonBlob,
}
// Run the DecoderOption func()s.
for _, o := range opts {
o(d)
}
return d
}
// Decode decodes the JSON document. On success, one of several values is
// returned.
//
// The possible results are:
// &rdap.Error{} - Responses with an errorCode value.
// &rdap.Autnum{} - Responses with objectClassName="autnum".
// &rdap.Domain{} - Responses with objectClassName="domain".
// &rdap.Entity{} - Responses with objectClassName="entity".
// &rdap.IPNetwork{} - Responses with objectClassName="ip network".
// &rdap.Nameserver{} - Responses with objectClassName="nameserver".
// &rdap.DomainSearchResults{} - Responses with a domainSearchResults array.
// &rdap.EntitySearchResults{} - Responses with a entitySearchResults array.
// &rdap.NameserverSearchResults{} - Responses with a nameserverSearchResults array.
// &rdap.Help{} - All other valid JSON responses.
//
// On serious errors (e.g. JSON syntax error) an error is returned. Otherwise,
// decoding is performed on a best-effort basis, and "minor errors" (such as
// incorrect JSON types) are ignored. This avoids minor errors rendering the
// whole response undecodable.
//
// Minor error messages (e.g. type conversions, type errors) are embedded within
// each result struct, see the DecodeData fields.
func (d *Decoder) Decode() (interface{}, error) {
var s map[string]interface{}
var err error
// Unmarshal the JSON document.
err = json.Unmarshal(d.data, &s)
if err != nil {
return nil, err
}
// Decode the RDAP response.
var result interface{}
result, err = d.decodeTopLevel(s)
return result, err
}
// decodeTopLevel decodes the top level object |src|.
func (d *Decoder) decodeTopLevel(src map[string]interface{}) (interface{}, error) {
// Choose the target struct type.
if d.target != nil {
// Target already selected, e.g. tests use this.
} else if _, exists := src["errorCode"]; exists {
d.target = &Error{}
} else if o, exists := src["objectClassName"]; exists {
if objectClassName, ok := o.(string); ok {
switch objectClassName {
case "autnum":
d.target = &Autnum{}
case "domain":
d.target = &Domain{}
case "entity":
d.target = &Entity{}
case "ip network":
d.target = &IPNetwork{}
case "nameserver":
d.target = &Nameserver{}
default:
return nil, DecoderError{text: "objectClassName is not recognised"}
}
} else {
return nil, DecoderError{text: "objectClassName is not a string"}
}
} else if _, exists := src["domainSearchResults"]; exists {
d.target = &DomainSearchResults{}
} else if _, exists := src["entitySearchResults"]; exists {
d.target = &EntitySearchResults{}
} else if _, exists := src["nameserverSearchResults"]; exists {
d.target = &NameserverSearchResults{}
}
// Default to returning a Help{}.
//
// All remaining JSON documents are assumed to be Help responses. There's no
// way of distinguishing a Help response and a valid non-RDAP response.
if d.target == nil {
d.target = &Help{}
}
// Construct the result type.
result := reflect.New(reflect.TypeOf(d.target).Elem())
// Decode the response into the result type.
_, err := d.decode("", src, result, nil)
return result.Interface(), err
}
// decode decodes the JSON structure |src| into the value |dst|.
//
// The type of |dst| is predetermined, |src| must match it, or be convertable to
// it. |dst| can be a bool, float64, struct, ptr, string, slice, map, etc.
//
// |decodeData| is optional, and is used to store raw values/note minor errors.
// |keyName| is used while storing minor errors.
//
// Returns true if |dst| was set successfully.
func (d *Decoder) decode(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var success bool
var err error
// Choose and run the correct decoder for |dst|'s type.
switch dst.Kind() {
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
success, err = d.decodeUint(keyName, src, dst, decodeData)
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
success, err = d.decodeInt(keyName, src, dst, decodeData)
case reflect.Float64:
success, err = d.decodeFloat64(keyName, src, dst, decodeData)
case reflect.Bool:
success, err = d.decodeBool(keyName, src, dst, decodeData)
case reflect.Struct:
success, err = d.decodeStruct(keyName, src, dst, decodeData)
case reflect.Ptr:
success, err = d.decodePtr(keyName, src, dst, decodeData)
case reflect.String:
success, err = d.decodeString(keyName, src, dst, decodeData)
case reflect.Slice:
success, err = d.decodeSlice(keyName, src, dst, decodeData)
case reflect.Map:
success, err = d.decodeMap(keyName, src, dst, decodeData)
default:
panic("BUG: unknown destination type")
}
return success, err
}
// decodeSlice decodes |src| into the slice |dst|.
//
// If a minor error is encountered while decoding a value, it is ignored and not
// returned in the resulting slice.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeSlice(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
// Cast the input to a slice.
srcSlice, ok := src.([]interface{})
if !ok {
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting array")
return false, nil
}
// Construct the result slice.
result := reflect.MakeSlice(dst.Type(), 0, len(srcSlice))
// Foreach value in the input slice...
for _, v := range srcSlice {
// Construct a result value for it.
vdst := reflect.New(dst.Type().Elem())
// Decode into the result value.
success, err := d.decode(keyName, v, reflect.Indirect(vdst), decodeData)
if err != nil {
return false, err
}
// Only if the decode was successful, append to result slice.
if success {
result = reflect.Append(result, reflect.Indirect(vdst))
}
}
dst.Set(result)
return true, nil
}
// decodeMap decodes |src| into the map |dst|.
//
// Only destination maps with a string key are supported.
//
// If a minor error is encountered while decoding a map value, it is ignored and
// not returned in the resulting map.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeMap(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
if dst.Type().Key().Kind() != reflect.String {
panic("BUG: map key is not string")
}
srcMap, ok := src.(map[string]interface{})
if !ok {
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting object")
return false, nil
}
// Construct the result map.
result := reflect.MakeMap(dst.Type())
// Foreach |src| map key/value...
for k, v := range srcMap {
// Construct the result value.
vdst := reflect.New(dst.Type().Elem())
// Decode into the result value.
success, err := d.decode(keyName+":"+k, v, reflect.Indirect(vdst), decodeData)
if err != nil {
return false, err
}
// If the decode was successful, add to the result map.
if success {
result.SetMapIndex(reflect.ValueOf(k), reflect.Indirect(vdst))
}
}
dst.Set(result)
return true, nil
}
// decodeUint decodes |src| into the uint8/16/32/64 |dst|.
//
// This function can perform type conversions, warnings/errors are noted for
// these.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeUint(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var err error
var result uint64
success := true
switch src.(type) {
case bool:
if src.(bool) {
result = 1
}
d.addDecodeNote(decodeData, keyName, "bool to uint conversion")
case float64:
result = uint64(src.(float64))
d.addDecodeNote(decodeData, keyName, "float64 to uint conversion")
case string:
var convError error
result, convError = strconv.ParseUint(src.(string), 10, 64)
if convError != nil {
result = 0
success = false
d.addDecodeNote(decodeData, keyName, "error converting string to uint")
} else {
d.addDecodeNote(decodeData, keyName, "string to uint conversion")
}
case nil:
result = 0
d.addDecodeNote(decodeData, keyName, "null to uint conversion")
default:
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting float")
success = false
}
if success {
var maxVal uint64
// Check the result number is within range of the target type.
switch dst.Kind() {
case reflect.Uint8:
maxVal = math.MaxUint8
case reflect.Uint16:
maxVal = math.MaxUint16
case reflect.Uint32:
maxVal = math.MaxUint32
case reflect.Uint64:
maxVal = math.MaxUint64
default:
panic("Unexpected int type")
}
if result > maxVal {
d.addDecodeNote(decodeData, keyName, "error: number too large")
success = false
} else {
dst.SetUint(result)
}
}
return success, err
}
// decodeInt decodes |src| into the int8/16/32/64 |dst|.
//
// This function can perform type conversions, warnings/errors are noted for
// these.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeInt(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var err error
var result int64
success := true
switch src.(type) {
case bool:
if src.(bool) {
result = 1
}
d.addDecodeNote(decodeData, keyName, "bool to int conversion")
case float64:
result = int64(src.(float64))
d.addDecodeNote(decodeData, keyName, "float64 to int conversion")
case string:
var convError error
result, convError = strconv.ParseInt(src.(string), 10, 64)
if convError != nil {
result = 0
success = false
d.addDecodeNote(decodeData, keyName, "error converting string to int")
} else {
d.addDecodeNote(decodeData, keyName, "string to int conversion")
}
case nil:
result = 0
d.addDecodeNote(decodeData, keyName, "null to int conversion")
default:
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting float")
success = false
}
if success {
var minVal int64
var maxVal int64
// Check the result number is within range of the target type.
switch dst.Kind() {
case reflect.Int8:
minVal = math.MinInt8
maxVal = math.MaxInt8
case reflect.Int16:
minVal = math.MinInt16
maxVal = math.MaxInt16
case reflect.Int32:
minVal = math.MinInt32
maxVal = math.MaxInt32
case reflect.Int64:
minVal = math.MinInt64
maxVal = math.MaxInt64
default:
panic("Unexpected int type")
}
if result < minVal || result > maxVal {
d.addDecodeNote(decodeData, keyName, "error: number too small or large")
success = false
} else {
dst.SetInt(result)
}
}
return success, err
}
// decodeFloat64 decodes |src| into the float64 |dst|.
//
// This function can perform type conversions, warnings/errors are noted for
// these.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeFloat64(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var err error
var result float64
success := true
switch src.(type) {
case bool:
if src.(bool) {
result = 1.0
}
d.addDecodeNote(decodeData, keyName, "bool to float64 conversion")
case float64:
result = src.(float64)
case string:
var convError error
result, convError = strconv.ParseFloat(src.(string), 64)
if convError != nil {
result = 0.0
success = false
d.addDecodeNote(decodeData, keyName, "error converting string to float64")
} else {
d.addDecodeNote(decodeData, keyName, "string to float64 conversion")
}
case nil:
result = 0.0
d.addDecodeNote(decodeData, keyName, "null to float64 conversion")
default:
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting float")
success = false
}
dst.SetFloat(result)
return success, err
}
// decodeString decodes |src| into the string |dst|.
//
// This function can perform type conversions, warnings/errors are noted for
// these.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeString(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var err error
var result string
success := true
switch src.(type) {
case bool:
result = strconv.FormatBool(src.(bool))
d.addDecodeNote(decodeData, keyName, "bool to string conversion")
case float64:
result = strconv.FormatFloat(src.(float64), 'f', -1, 64)
d.addDecodeNote(decodeData, keyName, "float64 to string conversion")
case string:
result = src.(string)
case nil:
result = ""
d.addDecodeNote(decodeData, keyName, "null to empty string conversion")
default:
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting string")
success = false
}
dst.SetString(result)
return success, err
}
// decodeBool decodes |src| into the bool |dst|.
//
// This function can perform type conversions, warnings/errors are noted for
// these.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeBool(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var err error
var result bool
success := true
switch src.(type) {
case bool:
result = src.(bool)
case float64:
f := src.(float64)
if f != 0 {
result = true
}
d.addDecodeNote(decodeData, keyName, "float64 to bool conversion")
case string:
var convError error
result, convError = strconv.ParseBool(src.(string))
if convError != nil {
d.addDecodeNote(decodeData, keyName, "error converting string to bool")
result = false
success = false
} else {
d.addDecodeNote(decodeData, keyName, "string to bool conversion")
}
case nil:
result = false
d.addDecodeNote(decodeData, keyName, "null to bool conversion")
default:
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting bool")
success = false
}
dst.SetBool(result)
return success, err
}
// decodeStruct decodes |src| into the struct |dst|.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodeStruct(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var err error
// |src| must be a JSON object.
srcMap, ok := src.(map[string]interface{})
if !ok {
d.addDecodeNote(decodeData, keyName, "invalid JSON type, expecting object")
return false, nil
}
// Identify the fields in the struct we'll decode into.
// e.g. fields["port43"] => [some reflect.Value]
var fields map[string]reflect.Value
var myDecodeData *DecodeData
fields, myDecodeData = d.chooseFields(dst)
// If the result struct has a DecodeData...
if myDecodeData != nil {
// Save a snapshot of each field.
for name, value := range srcMap {
myDecodeData.values[name] = value
}
// Note the fields we know about, so unknown fields can be identified.
for name := range fields {
myDecodeData.isKnown[name] = true
}
}
// Foreach field in |srcMap|...
for name, value := range srcMap {
// If there's a matching Go field, decode into it...
if _, ok := fields[name]; ok {
_, err := d.decode(name, value, fields[name], myDecodeData)
if err != nil {
return false, err
}
}
}
return true, err
}
func (d *Decoder) chooseFields(v reflect.Value) (map[string]reflect.Value, *DecodeData) {
if v.Kind() != reflect.Struct {
panic("BUG: chooseFields called on non-struct")
}
var decodeData *DecodeData
fields := map[string]reflect.Value{}
vt := v.Type()
for i := 0; i < vt.NumField(); i++ {
structField := vt.Field(i)
if structField.Type.Kind() == reflect.Ptr && structField.Type.Elem().Name() == "DecodeData" {
if decodeData != nil {
panic("BUG: Multiple DecodeData fields in struct")
} else {
decodeData = &DecodeData{}
decodeData.init()
v.Field(i).Set(reflect.ValueOf(decodeData))
}
} else {
if structField.Anonymous {
subFields, subDecodeData := d.chooseFields(v.Field(i))
if subDecodeData != nil {
if decodeData != nil {
panic("BUG: Multiple DecodeData fields in struct")
} else {
decodeData = subDecodeData
}
}
for k, v := range subFields {
if _, exists := fields[k]; exists {
panic("BUG: Duplicate field " + k + " in struct")
}
fields[k] = v
}
} else if name, ok := d.getFieldName(structField); ok {
if _, exists := fields[name]; exists {
panic("BUG: Duplicate field " + name + " in struct")
}
fields[name] = v.Field(i)
switch fields[name].Kind() {
case reflect.Uint8,
reflect.Uint16,
reflect.Uint32,
reflect.Uint64,
reflect.Int8,
reflect.Int16,
reflect.Int32,
reflect.Int64,
reflect.Float64,
reflect.Bool,
reflect.Struct,
reflect.Ptr,
reflect.String,
reflect.Slice,
reflect.Map:
// These types are all supported.
default:
panic("BUG: Unsupported field type for " + name)
}
}
}
}
return fields, decodeData
}
// getFieldName returns the RDAP field name (if any) of |sf|.
//
// Returns the field name and true if |sf| has an RDAP field name. Otherwise
// returns empty string and false.
func (d *Decoder) getFieldName(sf reflect.StructField) (string, bool) {
// Handle non-exported fields.
if sf.Name[0:1] != strings.ToUpper(sf.Name[0:1]) {
if sf.Tag.Get("rdap") != "" {
panic("BUG: rdap tag on non-exported struct field")
}
return "", false
}
// The "rdap" struct tag specifies a custom RDAP field name.
name := sf.Tag.Get("rdap")
// Otherwise, the RDAP field name is the Go field name, with the first
// character lowercased.
//
// e.g. domain.Port43 => RDAP field name "port43".
if name == "" {
name = strings.ToLower(sf.Name[0:1]) + sf.Name[1:]
}
return name, true
}
// decodePtr decodes |src| into the ptr |dst|. The ptr is initialised to a new
// value if nil.
//
// The parameters and return variables are as per decode().
func (d *Decoder) decodePtr(keyName string, src interface{}, dst reflect.Value, decodeData *DecodeData) (bool, error) {
var success bool
var err error
if dst.Type().Elem().Name() == "VCard" {
vcard, vcardError := newVCardImpl(src)
if vcardError == nil {
dst.Set(reflect.ValueOf(vcard))
success = true
} else {
d.addDecodeNote(decodeData, keyName, vcardError.Error())
}
} else {
if dst.IsNil() {
value := reflect.New(dst.Type().Elem())
dst.Set(value)
}
success, err = d.decode(keyName, src, reflect.Indirect(dst), decodeData)
}
return success, err
}
// addDecodeNote adds a DecodeData note |msg| for the field |key|.
func (d *Decoder) addDecodeNote(decodeData *DecodeData, key string, msg string) {
if decodeData == nil {
return
}
if _, ok := decodeData.notes[key]; !ok {
decodeData.notes[key] = []string{}
}
decodeData.notes[key] = append(decodeData.notes[key], msg)
}
rdap-0.9.1/decoder_test.go 0000664 0000000 0000000 00000012576 14742271423 0015463 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"reflect"
"testing"
"github.com/davecgh/go-spew/spew"
"github.com/openrdap/rdap/test"
)
func TestDecodeEmpty(t *testing.T) {
type Empty struct {
}
runDecodeAndCompareTest(t, &Empty{}, `
{}
`, &Empty{})
}
func TestDecodeDecodeData(t *testing.T) {
type XYZ struct {
DecodeData *DecodeData
S1 string
S2 string `rdap:"s2Name"`
SF string
}
result, ok := runDecode(t, &XYZ{}, `
{
"s1": "S1",
"s2Name": "S2",
"sF": 1.5,
"unknown" : "value"
}`)
if !ok {
return
}
x := result.(*XYZ)
if x.S1 != "S1" || x.S2 != "S2" || x.SF != "1.5" {
t.Errorf("Decode values bad %v", x)
}
if x.DecodeData == nil {
t.Errorf("DecodeData not instantiated")
} else if len(x.DecodeData.Notes("sF")) != 1 {
t.Errorf("DecodeData notes not added")
} else if len(x.DecodeData.Fields()) != 4 {
t.Errorf("DecodeData Fields() bad")
} else if len(x.DecodeData.UnknownFields()) != 1 {
t.Errorf("DecodeData UnknownFields() bad")
} else if !reflect.DeepEqual(x.DecodeData.Value("unknown"), "value") {
t.Errorf("DecodeData bad Value()")
}
}
func TestDecodeVCard(t *testing.T) {
type XYZ struct {
VCard *VCard
}
result, ok := runDecode(t, &XYZ{}, `
{
"vCard": [
"vcard",
[
["version", {}, "text", "4.0"],
["fn", {}, "text", "First Last"]
]
]
}
`)
if !ok {
return
}
x := result.(*XYZ)
if x.VCard == nil {
t.Errorf("VCard not decoded")
} else if len(x.VCard.Properties) != 2 {
t.Errorf("VCard properties not decoded")
}
}
func TestDecodeSlice(t *testing.T) {
type XYZ struct {
S []string
}
runDecodeAndCompareTest(t, &XYZ{}, `
{
"s": ["a", "b"]
}
`, &XYZ{
S: []string{"a", "b"},
})
}
func TestDecodeMap(t *testing.T) {
type XYZ struct {
M map[string]string
}
runDecodeAndCompareTest(t, &XYZ{}, `
{
"m": {"a": "av", "b": "bv"}
}
`, &XYZ{
M: map[string]string{"a": "av", "b": "bv"},
})
}
func TestDecodeUints(t *testing.T) {
type XYZ struct {
A uint8
AOverflow uint8
B uint16
C uint32
D uint64
S uint8
BF uint8
BT uint8
N uint8
}
runDecodeAndCompareTest(t, &XYZ{}, `
{
"a": 100,
"aOverflow": 256,
"b": 200,
"c": 42,
"d": 43,
"s": "10",
"bF": false,
"bT": true,
"n": null
}
`, &XYZ{
A: 100,
AOverflow: 0,
B: 200,
C: 42,
D: 43,
S: 10,
BF: 0,
BT: 1,
N: 0,
})
}
func TestDecodeInts(t *testing.T) {
type XYZ struct {
A int8
AUnderflow int8
AOverflow int8
B int16
C int32
D int64
S int8
BF int8
BT int8
N int8
}
runDecodeAndCompareTest(t, &XYZ{}, `
{
"a": 100,
"aUnderflow": -129,
"aOverflow": 128,
"b": 200,
"c": 42,
"d": 43,
"s": "10",
"bF": false,
"bT": true,
"n": null
}
`, &XYZ{
A: 100,
AUnderflow: 0,
AOverflow: 0,
B: 200,
C: 42,
D: 43,
S: 10,
BF: 0,
BT: 1,
N: 0,
})
}
func TestDecodeFloat64(t *testing.T) {
type XYZ struct {
F float64
FPtr *float64
S1 float64
S2 float64
BF float64
BT float64
N float64
}
fptr := 1.5
runDecodeAndCompareTest(t, &XYZ{}, `
{
"f": 1.5,
"fPtr": 1.5,
"s1": "1.5",
"s2": "-1.5",
"bF": false,
"bT": true,
"n": null
}
`, &XYZ{
F: 1.5,
FPtr: &fptr,
S1: 1.5,
S2: -1.5,
BF: 0.0,
BT: 1.0,
N: 0.0,
})
}
func TestDecodeBool(t *testing.T) {
type XYZ struct {
B bool
BPtr *bool
SF bool
ST bool
FF bool
FT bool
N bool
}
bptr := true
runDecodeAndCompareTest(t, &XYZ{}, `
{
"b": true,
"bPtr": true,
"sF": "false",
"sT": "true",
"fF": 0,
"fT": 1,
"n": null
}
`, &XYZ{
B: true,
BPtr: &bptr,
ST: true,
SF: false,
FF: false,
FT: true,
N: false,
})
}
func TestDecodeString(t *testing.T) {
type XYZ struct {
S string
SPtr *string
BT string
BF string
F1 string
F2 string
N string
}
sptr := "sptr"
runDecodeAndCompareTest(t, &XYZ{}, `
{
"s": "test",
"sPtr": "sptr",
"bT": true,
"bF": false,
"f1": 1.0,
"f2": -3.14,
"n2": null
}
`, &XYZ{
S: "test",
SPtr: &sptr,
BT: "true",
BF: "false",
F1: "1",
F2: "-3.14",
N: "",
})
}
func TestDecodeBug1(t *testing.T) {
jsonBlob := test.LoadFile("rdap/rdap-pilot.verisignlabs.com/entity-1-VRSN")
d := NewDecoder([]byte(jsonBlob))
result, err := d.Decode()
t.Logf("%s %s\n", result, err)
}
func TestDecodeMismatchedTypes(t *testing.T) {
type C struct {
}
type XYZ struct {
A []string
B map[string]string
C C
}
runDecodeAndCompareTest(t, &XYZ{}, `
{
"a": {},
"b": [1,2,3],
"c": false
}
`, &XYZ{
A: nil,
B: nil,
C: C{},
})
}
func runDecode(t *testing.T, target interface{}, jsonBlob string) (interface{}, bool) {
d := NewDecoder([]byte(jsonBlob))
d.target = target
result, err := d.Decode()
if err != nil {
t.Errorf("While decoding '%s', got error: %s", jsonBlob, err)
return result, false
}
return result, true
}
func runDecodeAndCompareTest(t *testing.T, target interface{}, jsonBlob string, expected interface{}) {
result, ok := runDecode(t, target, jsonBlob)
if !ok {
return
}
if !reflect.DeepEqual(expected, result) {
t.Errorf("While decoding '%s':\nexpected %s\ngot %s",
jsonBlob,
spew.Sdump(expected),
spew.Sdump(result))
}
}
rdap-0.9.1/doc.go 0000664 0000000 0000000 00000002741 14742271423 0013555 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
// Package rdap implements a client for the Registration Data Access Protocol (RDAP).
//
// RDAP is a modern replacement for the text-based WHOIS (port 43) protocol. It provides registration data for domain names/IP addresses/AS numbers, and more, in a structured format.
//
// This client executes RDAP queries and returns the responses as Go values.
//
// Quick usage:
// client := &rdap.Client{}
// domain, err := client.QueryDomain("example.cz")
//
// if err == nil {
// fmt.Printf("Handle=%s Domain=%s\n", domain.Handle, domain.LDHName)
// }
// The QueryDomain(), QueryAutnum(), and QueryIP() methods all provide full contact information, and timeout after 30s.
//
// Normal usage:
// // Query example.cz.
// req := &rdap.Request{
// Type: rdap.DomainRequest,
// Query: "example.cz",
// }
//
// client := &rdap.Client{}
// resp, err := client.Do(req)
//
// if domain, ok := resp.Object.(*rdap.Domain); ok {
// fmt.Printf("Handle=%s Domain=%s\n", domain.Handle, domain.LDHName)
// }
//
// As of June 2017, all five number registries (AFRINIC, ARIN, APNIC, LANIC,
// RIPE) run RDAP servers. A small number of TLDs (top level domains) support
// RDAP so far, listed on https://data.iana.org/rdap/dns.json.
//
// The RDAP protocol uses HTTP, with responses in a JSON format. A bootstrapping mechanism (http://data.iana.org/rdap/) is used to determine the server to query.
package rdap
rdap-0.9.1/domain.go 0000664 0000000 0000000 00000003171 14742271423 0014255 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// Domain represents information about a DNS name and point of delegation.
//
// Domain is a topmost RDAP response object.
type Domain struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
ObjectClassName string
Notices []Notice
Handle string
LDHName string `rdap:"ldhName"`
UnicodeName string
Variants []Variant
Nameservers []Nameserver
SecureDNS *SecureDNS
Entities []Entity
Status []string
PublicIDs []PublicID `rdap:"publicIds"`
Remarks []Remark
Links []Link
Port43 string
Events []Event
Network *IPNetwork
}
// Variant is a subfield of Domain.
type Variant struct {
DecodeData *DecodeData
Common
Relation []string
IDNTable string `rdap:"idnTable"`
VariantNames []VariantName
}
// VariantName is a subfield of Variant.
type VariantName struct {
DecodeData *DecodeData
Common
LDHName string `rdap:"ldhName"`
UnicodeName string
}
// SecureDNS is ia subfield of Domain.
type SecureDNS struct {
DecodeData *DecodeData
Common
ZoneSigned *bool
DelegationSigned *bool
MaxSigLife *uint64
DS []DSData `rdap:"dsData"`
Keys []KeyData `rdap:"keyData"`
}
// DSData is a subfield of Domain.
type DSData struct {
DecodeData *DecodeData
Common
KeyTag *uint64
Algorithm *uint8
Digest string
DigestType *uint8
Events []Event
Links []Link
}
type KeyData struct {
DecodeData *DecodeData
Flags *uint16
Protocol *uint8
Algorithm *uint8
PublicKey string
Events []Event
Links []Link
}
rdap-0.9.1/entity.go 0000664 0000000 0000000 00000001271 14742271423 0014321 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// Entity represents information of an organisation or person.
//
// Entity is a topmost RDAP response object.
type Entity struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
ObjectClassName string
Notices []Notice
Handle string
VCard *VCard `rdap:"vcardArray"`
Roles []string
PublicIDs []PublicID `rdap:"publicIds"`
Entities []Entity
Remarks []Remark
Links []Link
Events []Event
AsEventActor []Event
Status []string
Port43 string
Networks []IPNetwork
Autnums []Autnum
}
rdap-0.9.1/error.go 0000664 0000000 0000000 00000000556 14742271423 0014143 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// Error represents an error response.
//
// Error is a topmost RDAP response object.
type Error struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
Notices []Notice
ErrorCode *uint16
Title string
Description []string
}
rdap-0.9.1/example_test.go 0000664 0000000 0000000 00000006103 14742271423 0015476 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap_test
import (
"fmt"
"github.com/openrdap/rdap"
)
func Example() {
var jsonBlob = []byte(`
{
"objectClassName": "domain",
"rdapConformance": ["rdap_level_0"],
"handle": "EXAMPLECOM",
"ldhName": "example.com",
"status": ["active"],
"entities": [
{
"objectClassName": "entity",
"handle": "EXAMPLECOMREG",
"roles": ["registrant"],
"vcardArray": [
"vcard",
[
["version", {}, "text", "4.0"],
["fn", {}, "text", "John Smith"],
["adr", {}, "text",
[
"Box 1",
"Suite 29",
"1234 Fake St",
"Toronto",
"ON",
"M5E 1W5",
"Canada"
]
],
["tel", {}, "uri", "tel:+1-555-555-5555"],
["email", {}, "text", "hi@example.com"]
]
]
}
]
}
`)
// Decode the response.
d := rdap.NewDecoder(jsonBlob)
result, err := d.Decode()
// Print the response.
if err != nil {
fmt.Printf("%s\n", err)
} else {
domain := result.(*rdap.Domain)
PrintDomain(domain)
}
// Output:
// Handle=EXAMPLECOM
// LDHName=example.com
// Status=[active]
// Contact 0, roles: [registrant]:
// Name : 'John Smith'
// POBox : 'Box 1'
// Ext : 'Suite 29'
// Street : '1234 Fake St'
// Locality : 'Toronto'
// Region : 'ON'
// PostalCode: 'M5E 1W5'
// Country : 'Canada'
// Tel : 'tel:+1-555-555-5555'
// Fax : ''
// Email : 'hi@example.com'
}
// PrintDomain prints some basic rdap.Domain fields.
func PrintDomain(d *rdap.Domain) {
// Registry unique identifier for the domain. Here, "example.cz".
fmt.Printf("Handle=%s\n", d.Handle)
// Domain name (LDH = letters, digits, hyphen). Here, "example.cz".
fmt.Printf("LDHName=%s\n", d.LDHName)
// Domain registration status. Here, "active".
// See https://tools.ietf.org/html/rfc7483#section-10.2.2.
fmt.Printf("Status=%v\n", d.Status)
// Contact information.
for i, e := range d.Entities {
// Contact roles, such as "registrant", "administrative", "billing".
// See https://tools.ietf.org/html/rfc7483#section-10.2.4.
fmt.Printf("Contact %d, roles: %v:\n", i, e.Roles)
// RDAP uses VCard for contact information, including name, address,
// telephone, and e-mail address.
if e.VCard != nil {
v := e.VCard
// Name.
fmt.Printf(" Name : '%s'\n", v.Name())
// Address.
fmt.Printf(" POBox : '%s'\n", v.POBox())
fmt.Printf(" Ext : '%s'\n", v.ExtendedAddress())
fmt.Printf(" Street : '%s'\n", v.StreetAddress())
fmt.Printf(" Locality : '%s'\n", v.Locality())
fmt.Printf(" Region : '%s'\n", v.Region())
fmt.Printf(" PostalCode: '%s'\n", v.PostalCode())
fmt.Printf(" Country : '%s'\n", v.Country())
// Phone numbers.
fmt.Printf(" Tel : '%s'\n", v.Tel())
fmt.Printf(" Fax : '%s'\n", v.Fax())
// Email address.
fmt.Printf(" Email : '%s'\n", v.Email())
// The raw VCard fields are also accessible.
}
}
}
rdap-0.9.1/go.mod 0000664 0000000 0000000 00000000572 14742271423 0013567 0 ustar 00root root 0000000 0000000 module github.com/openrdap/rdap
go 1.19
require (
github.com/alecthomas/kingpin/v2 v2.3.2
github.com/davecgh/go-spew v1.1.1
github.com/jarcoal/httpmock v1.3.0
github.com/mitchellh/go-homedir v1.1.0
golang.org/x/crypto v0.9.0
)
require (
github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 // indirect
github.com/xhit/go-str2duration/v2 v2.1.0 // indirect
)
rdap-0.9.1/go.sum 0000664 0000000 0000000 00000004152 14742271423 0013612 0 ustar 00root root 0000000 0000000 github.com/alecthomas/kingpin/v2 v2.3.2 h1:H0aULhgmSzN8xQ3nX1uxtdlTHYoPLu5AhHxWrKI6ocU=
github.com/alecthomas/kingpin/v2 v2.3.2/go.mod h1:0gyi0zQnjuFk8xrkNKamJoyUo382HRL7ATRpFZCw6tE=
github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 h1:s6gZFSlWYmbqAuRjVTiNNhvNRfY2Wxp9nhfyel4rklc=
github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137/go.mod h1:OMCwj8VM1Kc9e19TLln2VL61YJF0x1XFtfdL4JdbSyE=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/jarcoal/httpmock v1.3.0 h1:2RJ8GP0IIaWwcC9Fp2BmVi8Kog3v2Hn7VXM3fTd+nuc=
github.com/jarcoal/httpmock v1.3.0/go.mod h1:3yb8rc4BI7TCBhFY8ng0gjuLKJNquuDNiPaZjnENuYg=
github.com/maxatome/go-testdeep v1.12.0 h1:Ql7Go8Tg0C1D/uMMX59LAoYK7LffeJQ6X2T04nTH68g=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
github.com/xhit/go-str2duration/v2 v2.1.0 h1:lxklc02Drh6ynqX+DdPyp5pCKLUQpRT8bp8Ydu2Bstc=
github.com/xhit/go-str2duration/v2 v2.1.0/go.mod h1:ohY8p+0f07DiV6Em5LKB0s2YpLtXVyJfNt1+BlmyAsU=
golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
rdap-0.9.1/help.go 0000664 0000000 0000000 00000000454 14742271423 0013737 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// Help represents a help response.
//
// Help is a topmost RDAP response object.
type Help struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
Notices []Notice
}
rdap-0.9.1/ipnetwork.go 0000664 0000000 0000000 00000001251 14742271423 0015025 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// IPNetwork represents information of an IP Network.
//
// IPNetwork is a topmost RDAP response object.
type IPNetwork struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
ObjectClassName string
Notices []Notice
Handle string
StartAddress string
EndAddress string
IPVersion string `rdap:"ipVersion"`
Name string
Type string
Country string
ParentHandle string
Status []string
Entities []Entity
Remarks []Remark
Links []Link
Port43 string
Events []Event
}
rdap-0.9.1/nameserver.go 0000664 0000000 0000000 00000001341 14742271423 0015152 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
// Nameserver represents information of a DNS nameserver.
//
// Nameserver is a topmost RDAP response object.
type Nameserver struct {
DecodeData *DecodeData
Common
Conformance []string `rdap:"rdapConformance"`
ObjectClassName string
Notices []Notice
Handle string
LDHName string `rdap:"ldhName"`
UnicodeName string
IPAddresses *IPAddressSet `rdap:"ipAddresses"`
Entities []Entity
Status []string
Remarks []Remark
Links []Link
Port43 string
Events []Event
}
// IPAddressSet is a subfield of Nameserver.
type IPAddressSet struct {
DecodeData *DecodeData
Common
V6 []string
V4 []string
}
rdap-0.9.1/print.go 0000664 0000000 0000000 00000043304 14742271423 0014144 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"fmt"
"io"
"os"
"strconv"
"strings"
)
// Printer formats RDAP response objects as human readable text, and writes them
// to an io.Writer.
//
// The format resembles a WHOIS response.
type Printer struct {
// Output io.Writer.
//
// Defaults to os.Stdout.
Writer io.Writer
// RDAP responses typically consist of a nested set of objects,
// these are represented using indentation.
// Character to ident responses with.
//
// Defaults to ' ' (space character).
IndentChar rune
// Number of characters per indentation.
//
// Defaults to 2.
IndentSize uint
// OmitNotices prevents RDAP Notices from being printed.
OmitNotices bool
// OmitNotices prevents RDAP Remarks from being printed.
OmitRemarks bool
// BriefOutput shortens the output by omitting various objects. These are:
//
// Conformance, Notices, Remarks, Events, Port43, Variants, SecureDNS.
BriefOutput bool
// BriefLinks causes Link objects to be printed as a single line (the link),
// rather than as a multi-line object.
BriefLinks bool
}
func (p *Printer) Print(obj RDAPObject) {
if p.Writer == nil {
p.Writer = os.Stdout
}
if p.IndentSize == 0 {
p.IndentSize = 2
}
if p.IndentChar == '\000' {
p.IndentChar = ' '
}
p.printObject(obj, 0)
}
func (p *Printer) printObject(obj RDAPObject, indentLevel uint) {
if obj == nil {
return
}
switch v := obj.(type) {
case *Domain:
p.printDomain(v, indentLevel)
case *Entity:
p.printEntity(v, indentLevel)
case *Nameserver:
p.printNameserver(v, indentLevel)
case *Autnum:
p.printAutnum(v, indentLevel)
case *IPNetwork:
p.printIPNetwork(v, indentLevel)
case *Help:
p.printHelp(v, indentLevel)
case *Error:
p.printError(v, indentLevel)
case *DomainSearchResults:
p.printDomainSearchResults(v, indentLevel)
case *EntitySearchResults:
p.printEntitySearchResults(v, indentLevel)
case *NameserverSearchResults:
p.printNameserverSearchResults(v, indentLevel)
}
}
func (p *Printer) printNameserverSearchResults(sr *NameserverSearchResults, indentLevel uint) {
p.printHeading("Nameserver Search Results", indentLevel)
indentLevel++
if !p.BriefOutput {
for _, c := range sr.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range sr.Notices {
p.printNotice(n, indentLevel)
}
}
for _, n := range sr.Nameservers {
p.printNameserver(&n, indentLevel)
}
p.printUnknowns(sr.DecodeData, indentLevel)
}
func (p *Printer) printEntitySearchResults(sr *EntitySearchResults, indentLevel uint) {
p.printHeading("Entity Search Results", indentLevel)
indentLevel++
if !p.BriefOutput {
for _, c := range sr.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range sr.Notices {
p.printNotice(n, indentLevel)
}
}
for _, e := range sr.Entities {
p.printEntity(&e, indentLevel)
}
p.printUnknowns(sr.DecodeData, indentLevel)
}
func (p *Printer) printDomainSearchResults(sr *DomainSearchResults, indentLevel uint) {
p.printHeading("Domain Search Results", indentLevel)
indentLevel++
if !p.BriefOutput {
for _, c := range sr.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range sr.Notices {
p.printNotice(n, indentLevel)
}
}
for _, d := range sr.Domains {
p.printDomain(&d, indentLevel)
}
p.printUnknowns(sr.DecodeData, indentLevel)
}
func (p *Printer) printError(e *Error, indentLevel uint) {
p.printHeading("Error", indentLevel)
indentLevel++
if !p.BriefOutput {
for _, c := range e.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range e.Notices {
p.printNotice(n, indentLevel)
}
}
if e.ErrorCode != nil {
p.printValue("Error Code",
strconv.FormatUint(uint64(*e.ErrorCode), 10),
indentLevel)
}
p.printValue("Title", e.Title, indentLevel)
for _, d := range e.Description {
p.printValue("Description", d, indentLevel)
}
p.printUnknowns(e.DecodeData, indentLevel)
}
func (p *Printer) printHelp(h *Help, indentLevel uint) {
p.printHeading("Help", indentLevel)
indentLevel++
if !p.BriefOutput {
for _, c := range h.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range h.Notices {
p.printNotice(n, indentLevel)
}
}
p.printUnknowns(h.DecodeData, indentLevel)
}
func (p *Printer) printDomain(d *Domain, indentLevel uint) {
p.printHeading("Domain", indentLevel)
indentLevel++
p.printValue("Domain Name", d.LDHName, indentLevel)
p.printValue("Domain Name (Unicode)", d.UnicodeName, indentLevel)
p.printValue("Handle", d.Handle, indentLevel)
for _, s := range d.Status {
p.printValue("Status", s, indentLevel)
}
if !p.BriefOutput {
p.printValue("Port43", d.Port43, indentLevel)
}
for _, pid := range d.PublicIDs {
p.printPublicID(pid, indentLevel)
}
if !p.BriefOutput {
for _, c := range d.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range d.Notices {
p.printNotice(n, indentLevel)
}
}
if !p.BriefOutput || p.OmitRemarks {
for _, r := range d.Remarks {
p.printRemark(r, indentLevel)
}
}
for _, l := range d.Links {
p.printLink(l, indentLevel)
}
if !p.BriefOutput {
for _, e := range d.Events {
p.printEvent(e, indentLevel, false)
}
for _, v := range d.Variants {
p.printVariant(v, indentLevel)
}
if d.SecureDNS != nil {
p.printSecureDNS(d.SecureDNS, indentLevel)
}
}
for _, e := range d.Entities {
p.printEntity(&e, indentLevel)
}
for _, n := range d.Nameservers {
p.printNameserver(&n, indentLevel)
}
if d.Network != nil {
p.printIPNetwork(d.Network, indentLevel)
}
p.printUnknowns(d.DecodeData, indentLevel)
}
func (p *Printer) printAutnum(a *Autnum, indentLevel uint) {
p.printHeading("Autnum", indentLevel)
indentLevel++
p.printValue("Handle", a.Handle, indentLevel)
p.printValue("Name", a.Name, indentLevel)
p.printValue("Type", a.Type, indentLevel)
for _, s := range a.Status {
p.printValue("Status", s, indentLevel)
}
p.printValue("IP Version", a.IPVersion, indentLevel)
p.printValue("Country", a.Country, indentLevel)
if a.StartAutnum != nil {
p.printValue("StartAutnum",
strconv.FormatUint(uint64(*a.StartAutnum), 10),
indentLevel)
}
if a.EndAutnum != nil {
p.printValue("EndAutnum",
strconv.FormatUint(uint64(*a.EndAutnum), 10),
indentLevel)
}
if !p.BriefOutput {
for _, c := range a.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput {
p.printValue("Port43", a.Port43, indentLevel)
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range a.Notices {
p.printNotice(n, indentLevel)
}
}
if !p.BriefOutput || p.OmitRemarks {
for _, r := range a.Remarks {
p.printRemark(r, indentLevel)
}
}
for _, l := range a.Links {
p.printLink(l, indentLevel)
}
if !p.BriefOutput {
for _, e := range a.Events {
p.printEvent(e, indentLevel, false)
}
}
for _, e := range a.Entities {
p.printEntity(&e, indentLevel)
}
p.printUnknowns(a.DecodeData, indentLevel)
}
func (p *Printer) printNameserver(n *Nameserver, indentLevel uint) {
p.printHeading("Nameserver", indentLevel)
indentLevel++
p.printValue("Nameserver", n.LDHName, indentLevel)
p.printValue("Nameserver (Unicode)", n.UnicodeName, indentLevel)
p.printValue("Handle", n.Handle, indentLevel)
for _, s := range n.Status {
p.printValue("Status", s, indentLevel)
}
if !p.BriefOutput {
p.printValue("Port43", n.Port43, indentLevel)
}
if !p.BriefOutput {
for _, c := range n.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range n.Notices {
p.printNotice(n, indentLevel)
}
}
if !p.BriefOutput || p.OmitRemarks {
for _, r := range n.Remarks {
p.printRemark(r, indentLevel)
}
}
for _, l := range n.Links {
p.printLink(l, indentLevel)
}
if !p.BriefOutput {
for _, e := range n.Events {
p.printEvent(e, indentLevel, false)
}
}
if n.IPAddresses != nil {
p.printIPAddressSet(n.IPAddresses, indentLevel)
}
for _, e := range n.Entities {
p.printEntity(&e, indentLevel)
}
p.printUnknowns(n.DecodeData, indentLevel)
}
func (p *Printer) printIPAddressSet(s *IPAddressSet, indentLevel uint) {
p.printHeading("IP Addresses", indentLevel)
indentLevel++
for _, ip := range s.V6 {
p.printValue("IPv6", ip, indentLevel)
}
for _, ip := range s.V4 {
p.printValue("IPv4", ip, indentLevel)
}
p.printUnknowns(s.DecodeData, indentLevel)
}
func (p *Printer) printEntity(e *Entity, indentLevel uint) {
p.printHeading("Entity", indentLevel)
indentLevel++
p.printValue("Handle", e.Handle, indentLevel)
for _, s := range e.Status {
p.printValue("Status", s, indentLevel)
}
if !p.BriefOutput {
p.printValue("Port43", e.Port43, indentLevel)
}
for _, pid := range e.PublicIDs {
p.printPublicID(pid, indentLevel)
}
if !p.BriefOutput {
for _, c := range e.Conformance {
p.printValue("Conformance", c, indentLevel)
}
}
if !p.BriefOutput || p.OmitNotices {
for _, n := range e.Notices {
p.printNotice(n, indentLevel)
}
}
if !p.BriefOutput || p.OmitRemarks {
for _, r := range e.Remarks {
p.printRemark(r, indentLevel)
}
}
for _, l := range e.Links {
p.printLink(l, indentLevel)
}
if !p.BriefOutput {
for _, e := range e.Events {
p.printEvent(e, indentLevel, false)
}
for _, e := range e.AsEventActor {
p.printEvent(e, indentLevel, true)
}
}
for _, r := range e.Roles {
p.printValue("Role", r, indentLevel)
}
if e.VCard != nil {
for _, property := range e.VCard.Properties {
for _, str := range property.Values() {
p.printValue("vCard "+property.Name, str, indentLevel)
}
}
}
if !p.BriefOutput {
for _, ipn := range e.Networks {
p.printIPNetwork(&ipn, indentLevel)
}
for _, asn := range e.Autnums {
p.printAutnum(&asn, indentLevel)
}
for _, e := range e.Entities {
p.printEntity(&e, indentLevel)
}
}
p.printUnknowns(e.DecodeData, indentLevel)
}
func (p *Printer) printIPNetwork(n *IPNetwork, indentLevel uint) {
p.printHeading("IP Network", indentLevel)
indentLevel++
p.printValue("Handle", n.Handle, indentLevel)
p.printValue("Start Address", n.StartAddress, indentLevel)
p.printValue("End Address", n.EndAddress, indentLevel)
p.printValue("IP Version", n.IPVersion, indentLevel)
p.printValue("Name", n.Name, indentLevel)
p.printValue("Type", n.Type, indentLevel)
p.printValue("Country", n.Country, indentLevel)
p.printValue("ParentHandle", n.ParentHandle, indentLevel)
for _, s := range n.Status {
p.printValue("Status", s, indentLevel)
}
if !p.BriefOutput {
p.printValue("Port43", n.Port43, indentLevel)
}
if !p.BriefOutput || p.OmitNotices {
for _, no := range n.Notices {
p.printNotice(no, indentLevel)
}
}
if !p.BriefOutput || p.OmitRemarks {
for _, r := range n.Remarks {
p.printRemark(r, indentLevel)
}
}
for _, e := range n.Entities {
p.printEntity(&e, indentLevel)
}
for _, l := range n.Links {
p.printLink(l, indentLevel)
}
if !p.BriefOutput {
for _, e := range n.Events {
p.printEvent(e, indentLevel, false)
}
}
p.printUnknowns(n.DecodeData, indentLevel)
}
func (p *Printer) printPublicID(pid PublicID, indentLevel uint) {
p.printHeading("Public ID", indentLevel)
indentLevel++
p.printValue("Type", pid.Type, indentLevel)
p.printValue("Identifier", pid.Identifier, indentLevel)
p.printUnknowns(pid.DecodeData, indentLevel)
}
func (p *Printer) printSecureDNS(s *SecureDNS, indentLevel uint) {
p.printHeading("Secure DNS", indentLevel)
indentLevel++
if s.ZoneSigned != nil {
p.printValue("Zone Signed",
strconv.FormatBool(*s.ZoneSigned),
indentLevel)
}
if s.DelegationSigned != nil {
p.printValue("Delegation Signed",
strconv.FormatBool(*s.DelegationSigned),
indentLevel)
}
if s.MaxSigLife != nil {
p.printValue("Max Signature Life",
strconv.FormatUint(*s.MaxSigLife, 10),
indentLevel)
}
for _, ds := range s.DS {
p.printDSData(ds, indentLevel)
}
for _, key := range s.Keys {
p.printKeyData(key, indentLevel)
}
p.printUnknowns(s.DecodeData, indentLevel)
}
func (p *Printer) printKeyData(k KeyData, indentLevel uint) {
p.printHeading("Key", indentLevel)
indentLevel++
if k.Flags != nil {
p.printValue("Flags",
strconv.FormatUint(uint64(*k.Flags), 10),
indentLevel)
}
if k.Protocol != nil {
p.printValue("Protocol",
strconv.FormatUint(uint64(*k.Protocol), 10),
indentLevel)
}
if k.Algorithm != nil {
p.printValue("Algorithm",
strconv.FormatUint(uint64(*k.Algorithm), 10),
indentLevel)
}
p.printValue("Public Key", k.PublicKey, indentLevel)
if !p.BriefOutput {
for _, e := range k.Events {
p.printEvent(e, indentLevel, false)
}
}
for _, l := range k.Links {
p.printLink(l, indentLevel)
}
p.printUnknowns(k.DecodeData, indentLevel)
}
func (p *Printer) printDSData(d DSData, indentLevel uint) {
p.printHeading("DSData", indentLevel)
indentLevel++
if d.KeyTag != nil {
p.printValue("Key Tag",
strconv.FormatUint(uint64(*d.KeyTag), 10),
indentLevel)
}
if d.Algorithm != nil {
p.printValue("Algorithm",
strconv.FormatUint(uint64(*d.Algorithm), 10),
indentLevel)
}
p.printValue("Digest", d.Digest, indentLevel)
if d.DigestType != nil {
p.printValue("DigestType",
strconv.FormatUint(uint64(*d.DigestType), 10),
indentLevel)
}
if !p.BriefOutput {
for _, e := range d.Events {
p.printEvent(e, indentLevel, false)
}
}
for _, l := range d.Links {
p.printLink(l, indentLevel)
}
p.printUnknowns(d.DecodeData, indentLevel)
}
func (p *Printer) printVariant(v Variant, indentLevel uint) {
p.printHeading("Variant", indentLevel)
indentLevel++
for _, r := range v.Relation {
p.printValue("Relation", r, indentLevel)
}
p.printValue("IDN Table", v.IDNTable, indentLevel)
for _, vn := range v.VariantNames {
p.printVariantName(vn, indentLevel)
}
p.printUnknowns(v.DecodeData, indentLevel)
}
func (p *Printer) printVariantName(vn VariantName, indentLevel uint) {
p.printHeading("Variant Name", indentLevel)
indentLevel++
p.printValue("Domain Name", vn.LDHName, indentLevel)
p.printValue("Domain Name (Unicode)", vn.UnicodeName, indentLevel)
p.printUnknowns(vn.DecodeData, indentLevel)
}
func (p *Printer) printRemark(r Remark, indentLevel uint) {
p.printHeading("Remark", indentLevel)
indentLevel++
p.printValue("Title", r.Title, indentLevel)
p.printValue("Type", r.Type, indentLevel)
for _, d := range r.Description {
p.printValue("Description", d, indentLevel)
}
for _, l := range r.Links {
p.printLink(l, indentLevel)
}
p.printUnknowns(r.DecodeData, indentLevel)
}
func (p *Printer) printNotice(n Notice, indentLevel uint) {
p.printHeading("Notice", indentLevel)
indentLevel++
p.printValue("Title", n.Title, indentLevel)
p.printValue("Type", n.Type, indentLevel)
for _, d := range n.Description {
p.printValue("Description", d, indentLevel)
}
for _, l := range n.Links {
p.printLink(l, indentLevel)
}
p.printUnknowns(n.DecodeData, indentLevel)
}
func (p *Printer) printLink(l Link, indent uint) {
if p.BriefLinks {
p.printValue("Link", l.Href, indent)
return
}
p.printHeading("Link", indent)
indent++
p.printValue("Title", l.Title, indent)
p.printValue("Href", l.Href, indent)
p.printValue("Value", l.Value, indent)
p.printValue("Rel", l.Rel, indent)
p.printValue("Media", l.Media, indent)
p.printValue("Type", l.Type, indent)
for _, h := range l.HrefLang {
p.printValue("HrefLang", h, indent)
}
p.printUnknowns(l.DecodeData, indent)
}
func (p *Printer) printHeading(heading string, indentLevel uint) {
fmt.Fprintf(p.Writer, "%s%s:\n",
strings.Repeat(string(p.IndentChar), int(indentLevel*p.IndentSize)),
p.cleanString(heading))
}
func (p *Printer) printValue(name string, value string, indentLevel uint) {
if value == "" {
return
}
fmt.Fprintf(p.Writer, "%s%s: %s\n",
strings.Repeat(string(p.IndentChar), int(indentLevel*p.IndentSize)),
p.cleanString(name),
p.cleanString(value))
}
func (p *Printer) printEvent(e Event, indentLevel uint, asEventActor bool) {
if p.BriefOutput {
return
}
if asEventActor {
p.printHeading("AsEventActor", indentLevel)
} else {
p.printHeading("Event", indentLevel)
}
indentLevel++
p.printValue("Action", e.Action, indentLevel)
p.printValue("Actor", e.Actor, indentLevel)
p.printValue("Date", e.Date, indentLevel)
for _, l := range e.Links {
p.printLink(l, indentLevel)
}
p.printUnknowns(e.DecodeData, indentLevel)
}
func (p *Printer) printUnknowns(d *DecodeData, indentLevel uint) {
if d == nil {
return
}
for k, v := range d.values {
isKnown, _ := d.isKnown[k]
isOverrided, _ := d.overrideKnownValue[k]
if !(isKnown && !isOverrided) {
p.printUnknown(k, v, indentLevel)
}
}
}
func (p *Printer) printUnknown(key string, value interface{}, indentLevel uint) {
switch value.(type) {
case bool:
p.printValue(key, strconv.FormatBool(value.(bool)), indentLevel)
case float64:
p.printValue(key, strconv.FormatFloat(value.(float64), 'f', -1, 64), indentLevel)
case string:
p.printValue(key, value.(string), indentLevel)
case []interface{}:
for _, value2 := range value.([]interface{}) {
p.printUnknown(key, value2, indentLevel)
}
case map[string]interface{}:
p.printHeading(key, indentLevel)
indentLevel++
for key2, value2 := range value.(map[string]interface{}) {
p.printUnknown(key2, value2, indentLevel)
}
default:
p.printValue(key, "[unprintable value]", indentLevel)
}
}
func (p *Printer) cleanString(str string) string {
return strings.Map(removeBadRunes, str)
}
func removeBadRunes(r rune) rune {
switch r {
case '\n', '\r', '\000':
return -1
default:
return r
}
}
rdap-0.9.1/print_test.go 0000664 0000000 0000000 00000001070 14742271423 0015175 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"testing"
"github.com/openrdap/rdap/test"
)
func TestPrintDomain(t *testing.T) {
obj := loadObject("rdap/rdap.nic.cz/domain-example.cz.json")
printer := &Printer{
BriefLinks: true,
}
_ = obj
_ = printer
//printer.Print(obj)
}
func loadObject(filename string) RDAPObject {
jsonBlob := test.LoadFile(filename)
d := NewDecoder([]byte(jsonBlob))
result, err := d.Decode()
if err != nil {
panic("Decode unexpectedly failed")
}
return result
}
rdap-0.9.1/request.go 0000664 0000000 0000000 00000031773 14742271423 0014507 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"context"
"fmt"
"net"
"net/url"
"strconv"
"strings"
"time"
)
// A RequestType specifies an RDAP request type.
type RequestType uint8
const (
_ RequestType = iota
AutnumRequest
DomainRequest
EntityRequest
HelpRequest
IPRequest
NameserverRequest
DomainSearchRequest
DomainSearchByNameserverRequest
DomainSearchByNameserverIPRequest
NameserverSearchRequest
NameserverSearchByNameserverIPRequest
EntitySearchRequest
EntitySearchByHandleRequest
// RawRequest is a request with a fixed RDAP URL.
RawRequest
)
// String returns the RequestType as a string.
// e.g. "autnum", "domain", "help".
func (r RequestType) String() string {
switch r {
case AutnumRequest:
return "autnum"
case DomainRequest:
return "domain"
case EntityRequest:
return "entity"
case HelpRequest:
return "help"
case IPRequest:
return "ip"
case NameserverRequest:
return "nameserver"
case DomainSearchRequest:
return "domain-search"
case DomainSearchByNameserverRequest:
return "domain-search-by-nameserver"
case DomainSearchByNameserverIPRequest:
return "domain-search-by-nameserver-ip"
case NameserverSearchRequest:
return "nameserver-search"
case NameserverSearchByNameserverIPRequest:
return "nameserver-search-by-ip"
case EntitySearchRequest:
return "entity-search"
case EntitySearchByHandleRequest:
return "entity-search-by-handle"
case RawRequest:
return "url"
default:
panic("Unknown RequestType")
}
}
// A Request represents an RDAP request.
//
// req := &rdap.Request{
// Type: rdap.DomainRequest,
// Query: "example.cz",
// }
//
// RDAP supports many request types. These are:
//
// RequestType | Bootstrapped? | HTTP request path | Example Query
// -------------------------------------------+---------------+-------------------------+----------------
// rdap.AutnumRequest | Yes | autnum/QUERY | AS2846
// rdap.DomainRequest | Yes | domain/QUERY | example.cz
// rdap.EntityRequest | Experimental | entity/QUERY | 86860670-VRSN
// rdap.HelpRequest | No | help | N/A
// rdap.IPRequest | Yes | ip/QUERY | 2001:db8::1
// rdap.NameserverRequest | No | nameserver/QUERY | ns1.skip.org
// | | |
// rdap.DomainSearchRequest | No | domains?name=QUERY | exampl*.com
// rdap.DomainSearchByNameserverRequest | No | domains?nsLdhName=QUERY | ns1.exampl*.com
// rdap.DomainSearchByNameserverIPRequest | No | domains?nsIp=QUERY | 192.0.2.0
// rdap.NameserverSearchRequest | No | nameservers?name=QUERY | ns1.exampl*.com
// rdap.NameserverSearchByNameserverIPRequest | No | nameservers?ip=QUERY | 192.0.2.0
// rdap.EntitySearchRequest | No | entities?fn=QUERY | ABC*-VRSN
// rdap.EntitySearchByHandleRequest | No | entities?handle=QUERY | ABC*-VRSN
// | | |
// rdap.RawRequest | N/A | N/A | N/A
//
// See https://tools.ietf.org/html/rfc7482 for more information on RDAP request
// types.
//
// Requests are executed by a Client. To execute a Request, an RDAP server is
// required. The servers for Autnum, IP, and Domain queries are determined
// automatically via bootstrapping (a lookup at https://data.iana.org/rdap/).
//
// For other Request types, you must specify the RDAP server:
//
// // Nameserver query on rdap.nic.cz.
// server, _ := url.Parse("https://rdap.nic.cz")
// req := &rdap.Request{
// Type: rdap.NameserverRequest,
// Query: "a.ns.nic.cz",
//
// Server: server,
// }
//
// RawRequest is a special case for existing RDAP request URLs:
// rdapURL, _ := url.Parse("https://rdap.example/mystery/query?ip=192.0.2.0")
// req := &rdap.Request{
// Type: rdap.RawRequest,
// Server: rdapURL,
// }
type Request struct {
// Request type.
Type RequestType
// Request query text.
Query string
// Optional URL query parameters to include in the RDAP request.
//
// These are added to the URL returned by URL().
Params url.Values
// Optional RDAP server URL.
//
// If present, specifies the RDAP server to execute the Request on.
// Otherwise, nil enables bootstrapping.
//
// For Type=RawRequest, this specifies the full RDAP URL instead (with the
// Query/Params fields not used).
Server *url.URL
// Optional list of contact roles. This enables additional HTTP requests for
// these contact roles, to obtain full contact information.
//
// The common WHOIS contact roles are "registrant", "administrative", and
// "billing".
//
// RDAP responses may contain full contact information (such as domain
// registrant name & address), or just a URL to it. For convenience,
// applications may prefer to receive the full contact information.
//
// The FetchRoles option enables additional HTTP requests for contact
// information. Additional HTTP requests are made for URL-only contact roles
// matching the FetchRoles list. Additional information is then merged into
// the Response.
//
// Specify a list of contact roles for which additional HTTP requests may be
// made. The default is no extra fetches. Use the special string "all" to
// fetch all available contact information.
FetchRoles []string
// Maximum request duration before timeout.
//
// The default is no timeout.
Timeout time.Duration
ctx context.Context
}
func (r *Request) pathAndValues() (string, url.Values) {
path := ""
values := url.Values{}
switch r.Type {
case AutnumRequest:
path = fmt.Sprintf("autnum/%s", escapePath(r.Query))
case DomainRequest:
path = fmt.Sprintf("domain/%s", escapePath(r.Query))
case EntityRequest:
path = fmt.Sprintf("entity/%s", escapePath(r.Query))
case HelpRequest:
path = "help"
case IPRequest:
// TODO: escape IP address/nets?
path = fmt.Sprintf("ip/%s", r.Query)
case NameserverRequest:
path = fmt.Sprintf("nameserver/%s", escapePath(r.Query))
case DomainSearchRequest:
path = "domains"
values["name"] = []string{r.Query}
case DomainSearchByNameserverRequest:
path = "domains"
values["nsLdhName"] = []string{r.Query}
case DomainSearchByNameserverIPRequest:
path = "domains"
values["nsIp"] = []string{r.Query}
case NameserverSearchRequest:
path = "nameservers"
values["name"] = []string{r.Query}
case NameserverSearchByNameserverIPRequest:
path = "nameservers"
values["ip"] = []string{r.Query}
case EntitySearchRequest:
path = "entities"
values["fn"] = []string{r.Query}
case EntitySearchByHandleRequest:
path = "entities"
values["handle"] = []string{r.Query}
case RawRequest:
// Server URL(s) are the entire request.
default:
panic("unknown QueryType")
}
return path, values
}
// URL constructs and returns the RDAP Request URL.
//
// As an example:
// server, _ := url.Parse("https://rdap.nic.cz")
// req := &rdap.Request{
// Type: rdap.NameserverRequest,
// Query: "a.ns.nic.cz",
//
// Server: server,
// }
//
// fmt.Println(req.URL()) // Prints https://rdap.nic.cz/nameserver/a.ns.nic.cz.
//
// Returns nil if the Server field is nil.
//
// For Type=RawRequest, the Server field is returned unmodified.
func (r *Request) URL() *url.URL {
if r.Server == nil {
return nil
}
path, values := r.pathAndValues()
var resultURL *url.URL
if r.Type == RawRequest {
resultURL = new(url.URL)
*resultURL = *r.Server
} else {
tempURL := &*r.Server
tempURL.RawQuery = ""
tempURL.Fragment = ""
tempURLString := tempURL.String()
if len(tempURLString) == 0 || tempURLString[len(tempURLString)-1] != '/' {
tempURLString += "/"
}
tempURLString += path
var err error
resultURL, err = url.Parse(tempURLString)
if err != nil {
return nil
}
query := r.Server.Query()
for k, v := range r.Params {
query[k] = v
}
for k, v := range values {
query[k] = v
}
resultURL.RawQuery = query.Encode()
resultURL.Fragment = r.Server.Fragment
}
return resultURL
}
// WithContext returns a copy of the Request, with Context |ctx|.
func (r *Request) WithContext(ctx context.Context) *Request {
r2 := new(Request)
*r2 = *r
r2.ctx = ctx
return r2
}
// Context returns the Request's context.
//
// The returned context is always non-nil; it defaults to the background context.
func (r *Request) Context() context.Context {
if r.ctx == nil {
return context.Background()
}
return r.ctx
}
// WithServer returns a copy of the Request, with the Server set to |server|.
func (r *Request) WithServer(server *url.URL) *Request {
r2 := new(Request)
*r2 = *r
r2.Server = server
return r2
}
func escapePath(text string) string {
var escaped []byte
for i := 0; i < len(text); i++ {
b := text[i]
if !shouldPathEscape(b) {
escaped = append(escaped, b)
} else {
escaped = append(escaped, '%',
"0123456789ABCDEF"[b>>4],
"0123456789ABCDEF"[b&0xF],
)
}
}
return string(escaped)
}
func shouldPathEscape(b byte) bool {
if ('A' <= b && b <= 'Z') || ('a' <= b && b <= 'z') || ('0' <= b && b <= '9') {
return false
}
switch b {
case '-', '_', '.', '~', '$', '&', '+', ':', '=', '@':
return false
}
return true
}
// NewHelpRequest creates a new help Request.
//
// The RDAP server must be specified.
func NewHelpRequest() *Request {
return &Request{
Type: HelpRequest,
}
}
// NewAutnumRequest creates a new Request for the AS number |asn|.
func NewAutnumRequest(asn uint32) *Request {
return &Request{
Type: AutnumRequest,
Query: fmt.Sprintf("%d", asn),
}
}
// NewIPRequest creates a new Request for the IP address |ip|.
func NewIPRequest(ip net.IP) *Request {
return &Request{
Type: IPRequest,
Query: ip.String(),
}
}
// NewIPNetRequest creates a new Request for the IP network |net|.
func NewIPNetRequest(net *net.IPNet) *Request {
return &Request{
Type: IPRequest,
Query: net.String(),
}
}
// NewDomainRequest creates a new Request for the domain name |domain|.
func NewDomainRequest(domain string) *Request {
return &Request{
Type: DomainRequest,
Query: domain,
}
}
// NewEntityRequest creates a new Request for the entity name |entity|.
//
// The RDAP server must be specified.
func NewEntityRequest(entity string) *Request {
return &Request{
Type: EntityRequest,
Query: entity,
}
}
// NewNameserverRequest creates a new Request for the nameserver |nameserver|.
//
// The RDAP server must be specified.
func NewNameserverRequest(nameserver string) *Request {
return &Request{
Type: NameserverRequest,
Query: nameserver,
}
}
// NewRawRequest creates a Request from the URL |rdapURL|.
//
// When a client executes the Request, it will fetch |rdapURL|.
func NewRawRequest(rdapURL *url.URL) *Request {
return &Request{
Type: RawRequest,
Server: rdapURL,
}
}
// NewRequest creates a new Request with type |requestType| and |query| text.
//
// Depending on the |requestType|, the RDAP server may need to be specified.
func NewRequest(requestType RequestType, query string) *Request {
return &Request{
Type: requestType,
Query: query,
}
}
// NewAutoRequest creates a Request by guessing the type required for |queryText|.
//
// The following types are suppported:
// - RawRequest - e.g. https://example.com/domain/example2.com
// - DomainRequest - e.g. example.com, https://example.com, http://example.com/
// - IPRequest - e.g. 192.0.2.0, 2001:db8::, 192.0.2.0/24, 2001:db8::/128
// - AutnumRequest - e.g. AS2856, 5400
// - EntityRequest - all other queries.
//
// Returns a Request. Use r.Type to find the RequestType chosen.
func NewAutoRequest(queryText string) *Request {
// Full RDAP URL?
fullURL, err := url.Parse(queryText)
if err == nil && (fullURL.Scheme == "http" || fullURL.Scheme == "https") {
// Parse "http://example.com/" as a domain query for convenience.
if fullURL.Path == "" || fullURL.Path == "/" {
return NewDomainRequest(fullURL.Host)
}
return NewRawRequest(fullURL)
}
// IP address?
ip := net.ParseIP(queryText)
if ip != nil {
return NewIPRequest(ip)
}
// IP network?
_, ipNet, err := net.ParseCIDR(queryText)
if ipNet != nil {
return NewIPNetRequest(ipNet)
}
// AS number? (formats: AS1234, as1234, 1234).
autnum, err := parseAutnum(queryText)
if err == nil {
return NewAutnumRequest(autnum)
}
// Looks like a domain name?
if strings.Contains(queryText, ".") {
return NewDomainRequest(queryText)
}
// Otherwise call it an entity query.
return NewEntityRequest(queryText)
}
func parseAutnum(autnum string) (uint32, error) {
autnum = strings.ToUpper(autnum)
autnum = strings.TrimPrefix(autnum, "AS")
result, err := strconv.ParseUint(autnum, 10, 32)
if err != nil {
return 0, err
}
return uint32(result), nil
}
rdap-0.9.1/request_test.go 0000664 0000000 0000000 00000012255 14742271423 0015540 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"net"
"net/url"
"testing"
)
const (
ExampleServer = "https://test.rdap.example/rdap"
)
func testRequestURL(t *testing.T, r *Request, path string) {
expectedURL := ExampleServer + "/" + path
server, _ := url.Parse(ExampleServer)
r2 := r.WithServer(server)
actualURL := r2.URL()
if actualURL == nil {
t.Errorf("Nil URL\n")
return
}
if actualURL.String() != expectedURL {
t.Errorf("Got URL %s, expected %s\n", actualURL.String(), expectedURL)
return
}
}
func TestNewAutnumRequest(t *testing.T) {
r := NewAutnumRequest(123456)
testRequestURL(t, r, "autnum/123456")
}
func TestNewIPv4Request(t *testing.T) {
r := NewIPRequest(net.ParseIP("192.0.2.0"))
testRequestURL(t, r, "ip/192.0.2.0")
}
func TestNewIPv6Request(t *testing.T) {
r := NewIPRequest(net.ParseIP("2001:DB8::a"))
testRequestURL(t, r, "ip/2001:db8::a")
}
func TestNewIPv4NetRequest(t *testing.T) {
_, ipNet, _ := net.ParseCIDR("192.0.2.0/24")
r := NewIPNetRequest(ipNet)
testRequestURL(t, r, "ip/192.0.2.0/24")
}
func TestNewIPv6NetRequest(t *testing.T) {
_, ipNet, _ := net.ParseCIDR("2001:DB8::1/128")
r := NewIPNetRequest(ipNet)
testRequestURL(t, r, "ip/2001:db8::1/128")
}
func TestNewNameserverRequest(t *testing.T) {
r := NewNameserverRequest("ns.example")
testRequestURL(t, r, "nameserver/ns.example")
}
func TestNewDomainRequest(t *testing.T) {
tests := []struct {
Query string
ExpectedPath string
}{
{"example.com", "domain/example.com"},
{"example/../com", "domain/example%2F..%2Fcom"},
}
for _, test := range tests {
r := NewDomainRequest(test.Query)
testRequestURL(t, r, test.ExpectedPath)
}
}
func TestNewEntityRequest(t *testing.T) {
tests := []struct {
Query string
ExpectedPath string
}{
{"MY-HANDLE", "entity/MY-HANDLE"},
{"MY-HANDLE/../com", "entity/MY-HANDLE%2F..%2Fcom"},
}
for _, test := range tests {
r := NewEntityRequest(test.Query)
testRequestURL(t, r, test.ExpectedPath)
}
}
func TestNewHelpRequest(t *testing.T) {
r := NewHelpRequest()
testRequestURL(t, r, "help")
}
func TestNewRawRequest(t *testing.T) {
urlString := "https://example.com/domain/example.com"
url, _ := url.Parse(urlString)
r := NewRawRequest(url)
actualURL := r.URL()
if actualURL.String() != urlString {
t.Errorf("Raw query for %s got %s, expected %s\n",
urlString,
actualURL.String(),
urlString,
)
}
}
func TestNewSearchRequests(t *testing.T) {
tests := []struct {
RequestType RequestType
Query string
ExpectedPath string
}{
{
DomainSearchRequest,
"example*.com&x=1",
"domains?name=example%2A.com%26x%3D1",
},
{
DomainSearchByNameserverRequest,
"example*.com&x=1",
"domains?nsLdhName=example%2A.com%26x%3D1",
},
{
DomainSearchByNameserverIPRequest,
"192.0.2.*.com&x=1",
"domains?nsIp=192.0.2.%2A.com%26x%3D1",
},
{
NameserverSearchRequest,
"ns1.example*.com&x=1",
"nameservers?name=ns1.example%2A.com%26x%3D1",
},
{
NameserverSearchByNameserverIPRequest,
"192.0.2.*.com&x=1",
"nameservers?ip=192.0.2.%2A.com%26x%3D1",
},
{
EntitySearchRequest,
"MY-FN*&x=1",
"entities?fn=MY-FN%2A%26x%3D1",
},
{
EntitySearchByHandleRequest,
"MY-HANDLE*&x=1",
"entities?handle=MY-HANDLE%2A%26x%3D1",
},
}
for _, test := range tests {
r := NewRequest(test.RequestType, test.Query)
testRequestURL(t, r, test.ExpectedPath)
}
}
func TestRequestURLConstruction(t *testing.T) {
tests := []struct {
Server string
Domain string
ExpectedURL string
}{
{"http://example.com", "example.org", "http://example.com/domain/example.org"},
{"http://example.com/", "example.org", "http://example.com/domain/example.org"},
{"http://example.com/1/", "example.org", "http://example.com/1/domain/example.org"},
{"http://example.com/1/", "example.org/", "http://example.com/1/domain/example.org%2F"},
{"https://example.com/x/", "example.com*.&x=1?z=1", "https://example.com/x/domain/example.com%2A.&x=1%3Fz=1"},
}
for _, test := range tests {
server, _ := url.Parse(test.Server)
r := NewDomainRequest(test.Domain)
r2 := r.WithServer(server)
actualURL := r2.URL()
if actualURL == nil {
t.Errorf("nil url")
} else if actualURL.String() != test.ExpectedURL {
t.Errorf("Got URL %s, expected %s\n", actualURL.String(), test.ExpectedURL)
}
}
}
func TestNewAutoRequest(t *testing.T) {
tests := []struct {
Query string
ExpectedType RequestType
}{
{"http://example.com/", DomainRequest},
{"https://example.com", DomainRequest},
{"http://example.com/domain/example.com", RawRequest},
{"https://example.com/domain/example.com", RawRequest},
{"192.0.2.0", IPRequest},
{"192.0.2.0/24", IPRequest},
{"2001:db8::", IPRequest},
{"2001:db8::/128", IPRequest},
{"AS1", AutnumRequest},
{"as12", AutnumRequest},
{"aS123", AutnumRequest},
{"1234", AutnumRequest},
{"example.com", DomainRequest},
{"example", EntityRequest},
}
for _, test := range tests {
r := NewAutoRequest(test.Query)
if r.Type != test.ExpectedType {
t.Errorf("AutoQuery detected %s as type %s, expected %s\n",
r.Query,
r.Type,
test.ExpectedType)
}
}
}
rdap-0.9.1/response.go 0000664 0000000 0000000 00000006103 14742271423 0014642 0 ustar 00root root 0000000 0000000 // OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.
package rdap
import (
"net/http"
"time"
"github.com/openrdap/rdap/bootstrap"
)
type Response struct {
Object RDAPObject
BootstrapAnswer *bootstrap.Answer
HTTP []*HTTPResponse
}
type RDAPObject interface{}
type HTTPResponse struct {
URL string
Response *http.Response
Body []byte
Error error
Duration time.Duration
}
type WhoisStyleResponse struct {
KeyDisplayOrder []string
Data map[string][]string
}
func (w *WhoisStyleResponse) add(key string, value string) {
if value == "" {
return
}
if _, exists := w.Data[key]; !exists {
w.KeyDisplayOrder = append(w.KeyDisplayOrder, key)
w.Data[key] = []string{value}
} else {
w.Data[key] = append(w.Data[key], value)
}
}
func newWhoisStyleResponse() *WhoisStyleResponse {
w := &WhoisStyleResponse{}
w.Data = make(map[string][]string)
return w
}
func (r *Response) ToWhoisStyleResponse() *WhoisStyleResponse {
w := newWhoisStyleResponse()
// Only support domain whois so far.
d, ok := r.Object.(*Domain)
if !ok {
return w
}
// "Domain Name"
w.add("Domain Name", d.LDHName)
// Registry Domain ID
w.add("Handle", d.Handle)
// "Registrar WHOIS Server"
w.add("Registrar WHOIS Server", d.Port43)
// Events.
for _, e := range d.Events {
switch e.Action {
case "last changed":
w.add("Updated Date", e.Date)
case "registration":
w.add("Creation Date", e.Date)
case "expiration":
w.add("Expiration Date", e.Date)
}
}
// Registrar fields.
registrar := findFirstEntity("registrar", d.Entities)
if registrar != nil {
vcard := registrar.VCard
if vcard != nil {
// "Registrar"
w.add("Registrar", vcard.Name())
}
// "Registrar IANA ID"
for _, id := range registrar.PublicIDs {
if id.Type == "IANA Registrar ID" {
w.add("Registrar IANA ID", id.Identifier)
}
}
// "Registrar Abuse Contact Email"
// "Registrar Abuse Contact Phone"
}
// "Domain Status"
for _, s := range d.Status {
w.add("Domain Status", s)
}
addEntityFields(w, "Registrant", findFirstEntity("registrant", d.Entities))
addEntityFields(w, "Admin", findFirstEntity("administrative", d.Entities))
addEntityFields(w, "Tech", findFirstEntity("technical", d.Entities))
addEntityFields(w, "Abuse", findFirstEntity("abuse", d.Entities))
// "Name Server"
for _, n := range d.Nameservers {
w.add("Name Server", n.LDHName)
}
return w
}
func addEntityFields(w *WhoisStyleResponse, t string, e *Entity) {
if e == nil {
return
}
v := e.VCard
if v == nil {
return
}
w.add(t+" Name", v.Name())
w.add(t+" PO Box", v.POBox())
w.add(t+" Extended Address", v.ExtendedAddress())
w.add(t+" Street", v.StreetAddress())
w.add(t+" Locality", v.Locality())
w.add(t+" Post Code", v.PostalCode())
w.add(t+" Country", v.Country())
w.add(t+" Tel", v.Tel())
w.add(t+" Fax", v.Fax())
w.add(t+" Email", v.Email())
}
func findFirstEntity(role string, entities []Entity) *Entity {
for _, e := range entities {
for _, r := range e.Roles {
if r == role {
return &e
}
}
}
return nil
}
rdap-0.9.1/sandbox/ 0000775 0000000 0000000 00000000000 14742271423 0014113 5 ustar 00root root 0000000 0000000 rdap-0.9.1/sandbox/DigiCert_RDAP_Pilot_Client_Certificate.p12 0000664 0000000 0000000 00000005417 14742271423 0023715 0 ustar 00root root 0000000 0000000 0‚ 0‚
Õ *†H†÷
‚
Æ‚
Â0‚
¾0‚ *†H†÷
‚0‚ 0‚ý *†H†÷
0
*†H†÷
0`›S= ôOD €‚Ð×ß<4HòÙ¢Û‚º¤Ql¥Kp€ëÓtfm6ÍÒ°rÒ)¸DFŸÕoUÝ 2¶}áÖuª@ tðêè™7å²>†®n†D6‡¦#©^Ù 2GQ5Êf®nRF9¶XMƒžK<´ïÇ $6e|U .’µè³¼F‘(- d ±dm7Õœç`2Õ&æ÷A‹ÆŽ“ÿ>ý,N¢PC 4FSD&Öå \9ù: "_IûÖ‚Y4&µ06<¬ÏQ8oxÖ‡K§WKt÷Z©hB¦«.Zn`‰A©Í¬YÛÉ
Fü•GDc93q7ŒW·kÐê¸ùËxÆq ôkýýÓ`Oœ7ÿ|Û•tÜA L;‚'¤_kõìÅ“VáÍÝnMÞS‡LÎãÁ+‹\®™'[ë0²åH¿ƒíWá)p7 ïèéÂ×XaäA¼Ëp=e¦KÂfG‚ñcþWÝR¦þ¢€kf-’¦ù5,{vü²UŽ‘±‰ÆG–À
n Y»Ü»]4NL”7 ¬Y¹åÿ‹‹VƒŠ'†àÛDìyÙ ¦ Ý}âIÀÔα;ÎóÂWfbû|WµÉ[‰ \ ›¼×<û79V!–º;Ü.œ§§í_ébwm/À‘V`ý=:¥ Š¢½;gÔ´CƒÄ Uâ@ËuË£N!½÷Ñ„†?Õó/Ž™H•‚c|«×_ðISÿ¯(W¸©SÌä’Î
ùBgŸeUàÙ͆ÅOëmÊ0ˆµISqeÚ½T…HI
»ï0Mhˆ2ÆSúdÀ™ÝäØÊ›)ÓLwWÅ.E •!Ê .Ô®Ù.}%¾óŸ,MB€ïæÆÞMP23Ó9EÚNlG¨*À [AªÝâ ¨2¸sïy@qèàê>@Ýr j€_tTY
& ‰ùGÊÄЊïq ÓüÝRSØê詆Æ7Hd„The requested URL was not found on this server. If you entered the URL manually please check your spelling and try again.