-spec getbyname(Name, Type) -> {ok, Hostent} | {error, Reason}
             when
                 Name :: dns_name(),
                 Type :: dns_rr_type(),
                 Hostent :: inet:hostent() | hostent(),
                 Reason :: inet:posix() | res_error().

Equivalent to getbyname/3.

-spec getbyname(Name, Type, Timeout) -> {ok, Hostent} | {error, Reason}
             when
                 Name :: dns_name(),
                 Type :: dns_rr_type(),
                 Timeout :: timeout(),
                 Hostent :: inet:hostent() | hostent(),
                 Reason :: inet:posix() | res_error().

Resolves a DNS record of the specified Type for the specified host, of class in. Returns, on success, when resolving a Type = a|aaaa DNS record, a #hostent{} record with #hostent.h_addrtype = inet|inet6, respectively; see inet:hostent/0.

When resolving other Type = dns_rr_type():s (of class in), also returns a #hostent{} record but with dns_rr_type/0 in #hostent.h_addrtype, and the resolved dns_data/0 in #hostent.h_addr_list; see hostent/0.

This function uses resolver option search that is a list of domain names. If the name to resolve contains no dots, it is prepended to each domain name in the search list, and they are tried in order. If the name contains dots, it is first tried as an absolute name and if that fails, the search list is used. If the name has a trailing dot, it is supposed to be an absolute name and the search list is not used.

-spec gethostbyaddr(Address) -> {ok, Hostent} | {error, Reason}
                 when
                     Address :: inet:ip_address(),
                     Hostent :: inet:hostent(),
                     Reason :: inet:posix() | res_error().

Equivalent to gethostbyaddr/2.

-spec gethostbyaddr(Address, Timeout) -> {ok, Hostent} | {error, Reason}
                 when
                     Address :: inet:ip_address(),
                     Timeout :: timeout(),
                     Hostent :: inet:hostent(),
                     Reason :: inet:posix() | res_error().

Backend functions used by inet:gethostbyaddr/1.

-spec gethostbyname(Name) -> {ok, Hostent} | {error, Reason}
                 when
                     Name :: dns_name(),
                     Hostent :: inet:hostent(),
                     Reason :: inet:posix() | res_error().

Equivalent to gethostbyname/3.

-spec gethostbyname(Name, Family) -> {ok, Hostent} | {error, Reason}
                 when
                     Name :: dns_name(),
                     Hostent :: inet:hostent(),
                     Family :: inet:address_family(),
                     Reason :: inet:posix() | res_error().

Equivalent to gethostbyname/3.

-spec gethostbyname(Name, Family, Timeout) -> {ok, Hostent} | {error, Reason}
                 when
                     Name :: dns_name(),
                     Hostent :: inet:hostent(),
                     Timeout :: timeout(),
                     Family :: inet:address_family(),
                     Reason :: inet:posix() | res_error().

Backend functions used by inet:gethostbyname/1,2.

This function uses resolver option search just like getbyname/2,3.

If resolver option inet6 is true, an IPv6 address is looked up.

-spec lookup(Name, Class, Type) -> [dns_data()]
          when Name :: dns_name() | inet:ip_address(), Class :: dns_class(), Type :: dns_rr_type().

Equivalent to lookup/5.

-spec lookup(Name, Class, Type, Opts) -> [dns_data()]
          when
              Name :: dns_name() | inet:ip_address(),
              Class :: dns_class(),
              Type :: dns_rr_type(),
              Opts :: [res_option() | verbose].

Equivalent to lookup/5.

-spec lookup(Name, Class, Type, Opts, Timeout) -> [dns_data()]
          when
              Name :: dns_name() | inet:ip_address(),
              Class :: dns_class(),
              Type :: dns_rr_type(),
              Opts :: [res_option() | verbose],
              Timeout :: timeout().

Resolves the DNS data for the record of the specified type and class for the specified name. On success, filters out the answer records with the correct Class and Type, and returns a list of their data fields. So, a lookup for type any gives an empty answer, as the answer records have specific types that are not any. An empty answer or a failed lookup returns an empty list.

Calls resolve/* with the same arguments and filters the result, so Opts is described for those functions.

-spec resolve(Name, Class, Type) -> {ok, dns_msg()} | Error
           when
               Name :: dns_name() | inet:ip_address(),
               Class :: dns_class(),
               Type :: dns_rr_type(),
               Error :: {error, Reason} | {error, {Reason, dns_msg()}},
               Reason :: inet:posix() | res_error().

Equivalent to resolve/5.

-spec resolve(Name, Class, Type, Opts) -> {ok, dns_msg()} | Error
           when
               Name :: dns_name() | inet:ip_address(),
               Class :: dns_class(),
               Type :: dns_rr_type(),
               Opts :: [Opt],
               Opt :: res_option() | verbose | atom(),
               Error :: {error, Reason} | {error, {Reason, dns_msg()}},
               Reason :: inet:posix() | res_error().

Equivalent to resolve/5.

-spec resolve(Name, Class, Type, Opts, Timeout) -> {ok, dns_msg()} | Error
           when
               Name :: dns_name() | inet:ip_address(),
               Class :: dns_class(),
               Type :: dns_rr_type(),
               Opts :: [Opt],
               Opt :: res_option() | verbose | atom(),
               Timeout :: timeout(),
               Error :: {error, Reason} | {error, {Reason, dns_msg()}},
               Reason :: inet:posix() | res_error().

Resolves a DNS record of the specified type and class for the specified name. The returned dns_msg/0 can be examined using access functions in inet_db, as described in section in DNS Types.

If Name is an ip_address(), the domain name to query for is generated as the standard reverse ".IN-ADDR.ARPA." name for an IPv4 address, or the ".IP6.ARPA." name for an IPv6 address. In this case, you most probably want to use Class = in and Type = ptr, but it is not done automatically.

Opts overrides the corresponding resolver options. If option nameservers is specified, it is assumed that it is the complete list of name serves, so resolver option alt_nameserves is ignored. However, if option alt_nameserves is also specified to this function, it is used.

Option verbose (or rather {verbose,true}) causes diagnostics printout through io:format/2 of queries, replies retransmissions, and so on, similar to from utilities, such as dig and nslookup.

Option nxdomain_reply (or rather {nxdomain_reply,true}) causes nxdomain errors from DNS servers to be returned as {error, {nxdomain, dns_msg()}}. dns_msg/0 contains the additional sections that where included by the answering server. This is mainly useful to inspect the SOA record to get the TTL for negative caching.

If Opt is any atom, it is interpreted as {Opt,true} unless the atom string starts with "no", making the interpretation {Opt,false}. For example, usevc is an alias for {usevc,true} and nousevc is an alias for {usevc,false}.

Option inet6 has no effect on this function. You probably want to use Type = a | aaaa instead.