rdap: github.com/openrdap/rdap Index | Examples | Files | Directories

package rdap

import "github.com/openrdap/rdap"

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.

Code:

// OpenRDAP
// Copyright 2017 Tom Harwood
// MIT License, see the LICENSE file.

package main

import (
    "fmt"

    "github.com/openrdap/rdap"
)

func main() {
    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)
    }

}

// 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.
        }
    }
}

Index

Examples

Package Files

autnum.go cli.go client.go client_error.go common.go decode_data.go decoder.go doc.go domain.go entity.go error.go help.go ipnetwork.go nameserver.go print.go request.go response.go search_results.go vcard.go

func RunCLI Uses

func RunCLI(args []string, stdout io.Writer, stderr io.Writer, options CLIOptions) int

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.

type Autnum Uses

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
}

Autnum represents information of Autonomous System registrations.

Autnum is a topmost RDAP response object.

type CLIOptions Uses

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
}

CLIOptions specifies options for the command line client.

type Client Uses

type Client struct {
    HTTP      *http.Client
    Bootstrap *bootstrap.Client

    // Optional callback function for verbose messages.
    Verbose func(text string)

    ServiceProviderExperiment bool
    UserAgent                 string
}

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)
}

func (*Client) Do Uses

func (c *Client) Do(req *Request) (*Response, error)

func (*Client) QueryAutnum Uses

func (c *Client) QueryAutnum(autnum string) (*Autnum, error)

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 (*Client) QueryDomain Uses

func (c *Client) QueryDomain(domain string) (*Domain, error)

QueryDomain makes an RDAP request for the |domain|.

Full contact information (where available) is provided. The timeout is 30s.

func (*Client) QueryIP Uses

func (c *Client) QueryIP(ip string) (*IPNetwork, error)

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.

type ClientError Uses

type ClientError struct {
    Type ClientErrorType
    Text string
}

func (ClientError) Error Uses

func (c ClientError) Error() string

type ClientErrorType Uses

type ClientErrorType uint
const (
    InputError ClientErrorType
    BootstrapNotSupported
    BootstrapNoMatch
    WrongResponseType
    NoWorkingServers
    ObjectDoesNotExist
    RDAPServerError
)

type Common Uses

type Common struct {
    Lang string
}

Common contains fields which may appear anywhere in an RDAP response.

type DSData Uses

type DSData struct {
    DecodeData *DecodeData

    Common
    KeyTag     *uint64
    Algorithm  *uint8
    Digest     string
    DigestType *uint8

    Events []Event
    Links  []Link
}

DSData is a subfield of Domain.

type DecodeData Uses

type DecodeData struct {
    // contains filtered or unexported fields
}

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.

func (DecodeData) Fields Uses

func (r DecodeData) Fields() []string

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 (DecodeData) Notes Uses

func (r DecodeData) Notes(name string) []string

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 (DecodeData) String Uses

func (r DecodeData) String() string

TODO (temporary, using for spew output)

func (DecodeData) UnknownFields Uses

func (r DecodeData) UnknownFields() []string

UnknownFields returns a list of unknown RDAP fields decoded.

func (DecodeData) Value Uses

func (r DecodeData) Value(name string) interface{}

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().

type Decoder Uses

type Decoder struct {
    // contains filtered or unexported fields
}

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.

func NewDecoder Uses

func NewDecoder(jsonBlob []byte, opts ...DecoderOption) *Decoder

NewDecoder creates a new Decoder to decode the RDAP response |jsonBlob|.

|opts| is an optional list of DecoderOptions.

func (*Decoder) Decode Uses

func (d *Decoder) Decode() (interface{}, error)

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.

type DecoderError Uses

type DecoderError struct {
    // contains filtered or unexported fields
}

DecoderError represents a fatal error encountered while decoding.

func (DecoderError) Error Uses

func (d DecoderError) Error() string

type DecoderOption Uses

type DecoderOption func(*Decoder)

DecoderOption sets a Decoder option.

type Domain Uses

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
}

Domain represents information about a DNS name and point of delegation.

Domain is a topmost RDAP response object.

type DomainSearchResults Uses

type DomainSearchResults struct {
    DecodeData *DecodeData

    Common
    Conformance []string `rdap:"rdapConformance"`
    Notices     []Notice

    Domains []Domain `rdap:"domainSearchResults"`
}

DomainSearchResults represents a domain search response.

DomainSearchResults is a topmost RDAP response object.

type Entity Uses

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
}

Entity represents information of an organisation or person.

Entity is a topmost RDAP response object.

type EntitySearchResults Uses

type EntitySearchResults struct {
    DecodeData *DecodeData

    Common
    Conformance []string `rdap:"rdapConformance"`
    Notices     []Notice

    Entities []Entity `rdap:"entitySearchResults"`
}

EntitySearchResults represents an entity search response.

EntitySearchResults is a topmost RDAP response object.

type Error Uses

type Error struct {
    DecodeData *DecodeData

    Common
    Conformance []string `rdap:"rdapConformance"`

    Notices []Notice

    ErrorCode   *uint16
    Title       string
    Description []string
}

Error represents an error response.

Error is a topmost RDAP response object.

type Event Uses

type Event struct {
    DecodeData *DecodeData

    Action string `rdap:"eventAction"`
    Actor  string `rdap:"eventActor"`
    Date   string `rdap:"eventDate"`
    Links  []Link
}

Event represents some event which has occured/may occur in the future..

https://tools.ietf.org/html/rfc7483#section-4.5

type HTTPResponse Uses

type HTTPResponse struct {
    URL      string
    Response *http.Response
    Body     []byte
    Error    error
    Duration time.Duration
}

type Help Uses

type Help struct {
    DecodeData *DecodeData

    Common
    Conformance []string `rdap:"rdapConformance"`
    Notices     []Notice
}

Help represents a help response.

Help is a topmost RDAP response object.

type IPAddressSet Uses

type IPAddressSet struct {
    DecodeData *DecodeData

    Common
    V6  []string
    V4  []string
}

IPAddressSet is a subfield of Nameserver.

type IPNetwork Uses

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
}

IPNetwork represents information of an IP Network.

IPNetwork is a topmost RDAP response object.

type KeyData Uses

type KeyData struct {
    DecodeData *DecodeData

    Flags     *uint16
    Protocol  *uint8
    Algorithm *uint8
    PublicKey string

    Events []Event
    Links  []Link
}
type Link struct {
    DecodeData *DecodeData

    Value    string
    Rel      string
    Href     string
    HrefLang []string `rdap:"hreflang"`
    Title    string
    Media    string
    Type     string
}

Link signifies a link another resource on the Internet.

https://tools.ietf.org/html/rfc7483#section-4.2

type Nameserver Uses

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
}

Nameserver represents information of a DNS nameserver.

Nameserver is a topmost RDAP response object.

type NameserverSearchResults Uses

type NameserverSearchResults struct {
    DecodeData *DecodeData

    Common
    Conformance []string `rdap:"rdapConformance"`
    Notices     []Notice

    Nameservers []Nameserver `rdap:"nameserverSearchResults"`
}

NameserverSearchResults represents a nameserver search response.

NameserverSearchResults is a topmost RDAP response object.

type Notice Uses

type Notice struct {
    DecodeData *DecodeData

    Title       string
    Type        string
    Description []string
    Links       []Link
}

Notice contains information about the entire RDAP response.

https://tools.ietf.org/html/rfc7483#section-4.3

type Printer Uses

type Printer struct {
    // Output io.Writer.
    //
    // Defaults to os.Stdout.
    Writer io.Writer

    // 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
}

Printer formats RDAP response objects as human readable text, and writes them to an io.Writer.

The format resembles a WHOIS response.

func (*Printer) Print Uses

func (p *Printer) Print(obj RDAPObject)

type PublicID Uses

type PublicID struct {
    DecodeData *DecodeData

    Type       string
    Identifier string
}

PublicID maps a public identifier to an object class.

https://tools.ietf.org/html/rfc7483#section-4.8

type RDAPObject Uses

type RDAPObject interface{}

type Remark Uses

type Remark 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 Request Uses

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
    // contains filtered or unexported fields
}

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,
}

func NewAutnumRequest Uses

func NewAutnumRequest(asn uint32) *Request

NewAutnumRequest creates a new Request for the AS number |asn|.

func NewAutoRequest Uses

func NewAutoRequest(queryText string) *Request

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 NewDomainRequest Uses

func NewDomainRequest(domain string) *Request

NewDomainRequest creates a new Request for the domain name |domain|.

func NewEntityRequest Uses

func NewEntityRequest(entity string) *Request

NewEntityRequest creates a new Request for the entity name |entity|.

The RDAP server must be specified.

func NewHelpRequest Uses

func NewHelpRequest() *Request

NewHelpRequest creates a new help Request.

The RDAP server must be specified.

func NewIPNetRequest Uses

func NewIPNetRequest(net *net.IPNet) *Request

NewIPNetRequest creates a new Request for the IP network |net|.

func NewIPRequest Uses

func NewIPRequest(ip net.IP) *Request

NewIPRequest creates a new Request for the IP address |ip|.

func NewNameserverRequest Uses

func NewNameserverRequest(nameserver string) *Request

NewNameserverRequest creates a new Request for the nameserver |nameserver|.

The RDAP server must be specified.

func NewRawRequest Uses

func NewRawRequest(rdapURL *url.URL) *Request

NewRawRequest creates a Request from the URL |rdapURL|.

When a client executes the Request, it will fetch |rdapURL|.

func NewRequest Uses

func NewRequest(requestType RequestType, query string) *Request

NewRequest creates a new Request with type |requestType| and |query| text.

Depending on the |requestType|, the RDAP server may need to be specified.

func (*Request) Context Uses

func (r *Request) Context() context.Context

Context returns the Request's context.

The returned context is always non-nil; it defaults to the background context.

func (*Request) URL Uses

func (r *Request) URL() *url.URL

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 (*Request) WithContext Uses

func (r *Request) WithContext(ctx context.Context) *Request

WithContext returns a copy of the Request, with Context |ctx|.

func (*Request) WithServer Uses

func (r *Request) WithServer(server *url.URL) *Request

WithServer returns a copy of the Request, with the Server set to |server|.

type RequestType Uses

type RequestType uint8

A RequestType specifies an RDAP request type.

const (
    AutnumRequest RequestType
    DomainRequest
    EntityRequest
    HelpRequest
    IPRequest
    NameserverRequest

    DomainSearchRequest
    DomainSearchByNameserverRequest
    DomainSearchByNameserverIPRequest
    NameserverSearchRequest
    NameserverSearchByNameserverIPRequest
    EntitySearchRequest
    EntitySearchByHandleRequest

    // RawRequest is a request with a fixed RDAP URL.
    RawRequest
)

func (RequestType) String Uses

func (r RequestType) String() string

String returns the RequestType as a string. e.g. "autnum", "domain", "help".

type Response Uses

type Response struct {
    Object          RDAPObject
    BootstrapAnswer *bootstrap.Answer
    HTTP            []*HTTPResponse
}

func (*Response) ToWhoisStyleResponse Uses

func (r *Response) ToWhoisStyleResponse() *WhoisStyleResponse

type SecureDNS Uses

type SecureDNS struct {
    DecodeData *DecodeData

    Common
    ZoneSigned       *bool
    DelegationSigned *bool
    MaxSigLife       *uint64
    DS               []DSData  `rdap:"dsData"`
    Keys             []KeyData `rdap:"keyData"`
}

SecureDNS is ia subfield of Domain.

type VCard Uses

type VCard struct {
    Properties []*VCardProperty
}

VCard represents a vCard.

A vCard represents information about an individual or entity. It can include a name, telephone number, e-mail, delivery address, and other information.

There are several vCard text formats. This implementation encodes/decodes the jCard format used by RDAP, as defined in https://tools.ietf.org/html/rfc7095.

A jCard consists of an array of properties (e.g. "fn", "tel") describing the individual or entity. Properties may be repeated, e.g. to represent multiple telephone numbers. RFC6350 documents a set of standard properties.

RFC7095 describes the JSON document format, which looks like:

["vcard", [
  [
    ["version", {}, "text", "4.0"],
    ["fn", {}, "text", "Joe Appleseed"],
    ["tel", {
          "type":["work", "voice"],
        },
        "uri",
        "tel:+1-555-555-1234;ext=555"
    ],
    ...
  ]
]

func NewVCard Uses

func NewVCard(jsonBlob []byte) (*VCard, error)

NewVCard creates a VCard from jsonBlob.

func (*VCard) Country Uses

func (v *VCard) Country() string

Country returns the address country name.

This is the full country name.

Returns empty string if no address is present.

func (*VCard) Email Uses

func (v *VCard) Email() string

Email returns the VCard's first email address.

Returns empty string if the VCard contains no email addresses.

func (*VCard) ExtendedAddress Uses

func (v *VCard) ExtendedAddress() string

ExtendedAddress returns the "extended address", e.g. an apartment or suite number.

Returns empty string if no address is present.

func (*VCard) Fax Uses

func (v *VCard) Fax() string

Fax returns the VCard's first fax number.

Returns empty string if the VCard contains no fax number.

func (*VCard) Get Uses

func (v *VCard) Get(name string) []*VCardProperty

Get returns a list of the vCard Properties with VCardProperty name |name|.

func (*VCard) GetFirst Uses

func (v *VCard) GetFirst(name string) *VCardProperty

GetFirst returns the first vCard Property with name |name|.

TODO(tfh): Implement "pref" ordering, instead of taking the first listed property?

func (*VCard) Locality Uses

func (v *VCard) Locality() string

Locality returns the address locality.

Returns empty string if no address is present.

func (*VCard) Name Uses

func (v *VCard) Name() string

Name returns the VCard's name. e.g. "John Smith".

func (*VCard) POBox Uses

func (v *VCard) POBox() string

POBox returns the address's PO Box.

Returns empty string if no address is present.

func (*VCard) PostalCode Uses

func (v *VCard) PostalCode() string

PostalCode returns the address postal code (e.g. zip code).

Returns empty string if no address is present.

func (*VCard) Region Uses

func (v *VCard) Region() string

Region returns the address region (e.g. state or province).

Returns empty string if no address is present.

func (*VCard) StreetAddress Uses

func (v *VCard) StreetAddress() string

StreetAddress returns the street address.

Returns empty string if no address is present.

func (*VCard) String Uses

func (v *VCard) String() string

String returns the vCard as a multiline human readable string. For example:

vCard[
  version (type=text, parameters=map[]): [4.0]
  mixed (type=text, parameters=map[]): [abc true 42 <nil> [def false 43]]
]

This is intended for debugging only, and is not machine parsable.

func (*VCard) Tel Uses

func (v *VCard) Tel() string

Tel returns the VCard's first (voice) telephone number.

Returns empty string if the VCard contains no suitable telephone number.

type VCardProperty Uses

type VCardProperty struct {
    Name string

    // vCard parameters can be a string, or array of strings.
    //
    // To simplify our usage, single strings are represented as an array of
    // length one.
    Parameters map[string][]string
    Type       string

    // A property value can be a simple type (string/float64/bool/nil), or be
    // an array. Arrays can be nested, and can contain a mixture of types.
    //
    // Value is one of the following:
    //   * string
    //   * float64
    //   * bool
    //   * nil
    //   * []interface{}. Can contain a mixture of these five types.
    //
    // To retrieve the property value flattened into a []string, use Values().
    Value interface{}
}

VCardProperty represents a single vCard property.

Each vCard property has four fields, these are:

 Name   Parameters                  Type   Value
 -----  --------------------------  -----  -----------------------------
["tel", {"type":["work", "voice"]}, "uri", "tel:+1-555-555-1234;ext=555"]

func (*VCardProperty) String Uses

func (p *VCardProperty) String() string

String returns the VCardProperty as a human readable string. For example:

mixed (type=text, parameters=map[]): [abc true 42 <nil> [def false 43]]

This is intended for debugging only, and is not machine parsable.

func (*VCardProperty) Values Uses

func (p *VCardProperty) Values() []string

Values returns a simplified representation of the VCardProperty value.

This is convenient for accessing simple unstructured data (e.g. "fn", "tel").

The simplified []string representation is created by flattening the (potentially nested) VCardProperty value, and converting all values to strings.

type Variant Uses

type Variant struct {
    DecodeData *DecodeData

    Common
    Relation     []string
    IDNTable     string `rdap:"idnTable"`
    VariantNames []VariantName
}

Variant is a subfield of Domain.

type VariantName Uses

type VariantName struct {
    DecodeData *DecodeData

    Common
    LDHName     string `rdap:"ldhName"`
    UnicodeName string
}

VariantName is a subfield of Variant.

type WhoisStyleResponse Uses

type WhoisStyleResponse struct {
    KeyDisplayOrder []string
    Data            map[string][]string
}

Directories

PathSynopsis
bootstrapPackage bootstrap implements an RDAP bootstrap client.
bootstrap/cachePackage cache implements RDAP Service Registry file caching.
sandbox
test

Package rdap imports 21 packages (graph) and is imported by 1 packages. Updated 2018-06-02. Refresh now. Tools for package owners.