DNS query: Difference between revisions

=={{header|Ada}}==

{{works with|GNAT GPL|Any - package Gnat.Sockets supports only IPv4 as of Jun 2011}}

with GNAT.Sockets; use GNAT.Sockets;

 

Inet_Addr_V4 := Addresses (Host);

Put ("IPv4: " & Image (Value => Inet_Addr_V4));

 

{{works with|GNAT GPL|2019 - support for IPv6 was added to Gnat.Sockets sometime before this}}

 

with GNAT.Sockets; use Gnat.Sockets;

procedure DNSQuerying is

begin

Print_Address_Info ("ipv6.google.com", "https", Family_Inet6);

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

pop {r0,r1,r2,r7,lr} @ restaur des 2 registres */

bx lr @ return

 

=={{header|AutoHotkey}}==

This code uses Windows built-in 'nslookup' command (and a temporary file):

Runwait, %comspec% /c nslookup %Url%>%LogFile%, , hide

FileRead, Contents, %LogFile%

FileDelete, %LogFile%

RegExMatch(Contents,"Addresses:.+(`r?`n\s+.+)*",Match)

 

=={{header|Batch File}}==

:: Batch File Implementation

 

)

endlocal

{{Out}}

<pre>DOMAIN: "www.kame.net"

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

AF_INET = 2

SYS `WSACleanup`

Output:

<pre>IPv4 address = 203.178.141.194

This solution uses <code>getaddrinfo()</code>, a standard function from RFC 3493. This code resembles an example from [http://www.openbsd.org/cgi-bin/man.cgi?query=getaddrinfo&apropos=0&sektion=3&manpath=OpenBSD+Current&arch=i386&format=html getaddrinfo(3)], the [[BSD]] manual page. Whereas the man page code connects to <code>www.kame.net</code>, this code only prints the numeric addresses.

 

#include <sys/socket.h>

#include <netdb.h> /* getaddrinfo, getnameinfo */

 

return 0;

 

=={{header|C sharp|C#}}==

Implementation takes a host name string as a parameter, and returns the IP addresses in a comma-delimited string. Note that a failed lookup throws a SocketException.

private string LookupDns(string s)

{

}

}

 

=={{header|C++}}==

This example makes use of the Boost library. The asio bit is header-only, but requires linking boost-system (e.g. -lboost_system). The compiler may also need to be told to use C++11 semantics (e.g. -std=c++11).

#include <boost/asio.hpp>

#include <iostream>

return rc;

}

 

=={{header|Caché ObjectScript}}==

 

Class Utils.Net Extends %RegisteredObject

{

 

}

 

Class Utils.OS Extends %RegisteredObject

{

 

}

{{out|Examples}}

<pre>

 

=={{header|Clojure}}==

 

(doseq [addr (InetAddress/getAllByName "www.kame.net")]

(cond

(instance? Inet4Address addr) (println "IPv4:" (.getHostAddress addr))

Output:

<pre>IPv4: 203.178.141.194

 

=={{header|CoffeeScript}}==

# runs under node.js

dns = require 'dns'

console.log 'IP6'

console.log addresses

 

=={{header|Common Lisp}}==

common lisp does not have a standard network api. the following examples are using native implementations

{{works with|SBCL}}

(sb-bsd-sockets:get-host-by-name "www.rosettacode.org"))

{{works with|CMUCL}}

(print (map 'list #'extensions:ip-string (host-entry-addr-list hostname))))

{{works with|Clozure}}

{{works with|Clisp}}

the usocket library contains a (get-hosts-by-name) function in all of its [http://trac.common-lisp.net/usocket/browser/usocket/trunk/backend backends]. unfortunately it does not expose the functions in its public interface. but since the license is MIT, it may be a suitable source to copy code for your own use.

 

{{libheader|iolib}} is a portable library that:

{{works with|SBCL}}{{works with|CMUCL}}{{works with|Clisp}}{{works with|Clozure}}

 

#/IOLIB.SOCKETS:IP/203.178.141.194

"orange.kame.net"

(("orange.kame.net" . #/IOLIB.SOCKETS:IP/203.178.141.194)

 

In Allegro Common Lisp there's a nice standard library called [http://franz.com/support/documentation/current/doc/socket.htm socket].

{{works with|Allegro}}

(socket:dns-query "www.rosettacode.org"))

 

In Lispworks the [http://www.lispworks.com/documentation/lw71/LW/html/lw-269.htm COMM] package provides information about IP addresses.

 

{{works with|Lispworks}}

(comm:ip-address-string (comm:get-host-entry "www.rosettacode.org" :fields '(:address)))

"104.28.10.103"

 

=={{header|Crystal}}==

 

Socket::Addrinfo.resolve(

).each { |a|

puts a.ip_address.address

{{out}}

<pre>

 

=={{header|D}}==

 

void main() {

a = getAddressInfo(domain, port, AddressFamily.INET6);

writefln("IPv6 address for %s: %s", domain, a[0].address);

<pre>IPv4 address for www.kame.net: 203.178.141.194:80

IPv6 address for www.kame.net: [2001:200:dff:fff1:216:3eff:feb1:44d7]:80</pre>

The included Indy components wrap GetAddressInfo.

 

 

{$APPTYPE CONSOLE}

lStack.Free;

end;

 

Output:

 

=={{header|Erlang}}==

33> {ok, {hostent, Host, Aliases, AddrType, Bytes, AddrList}} = inet:gethostbyname("www.kame.net", inet).

{ok,{hostent,"orange.kame.net",

37> [inet_parse:ntoa(Addr) || Addr <- AddrList].

["2001:200:DFF:FFF1:216:3EFF:FEB1:44D7"]

 

=={{header|Factor}}==

 

"www.kame.net" [ dns-A-query ] [ dns-AAAA-query ] bi

{{out}}

<pre>

 

=={{header|Frink}}==

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println(err)

}

Output:

<pre>

 

=={{header|Groovy}}==

println "IPv4: ${addresses.find { it instanceof Inet4Address }?.hostAddress}"

Output:

<pre>IPv4: 203.178.141.194

 

=={{header|Haskell}}==

 

import Network.Socket

main = showIPs "www.kame.net"

Output:

<pre>

The following was tested only in Unicon:

 

procedure main(A)

host := gethost( A[1] | "www.kame.net") | stop("can't translate")

write(host.name, ": ", host.addresses)

end

 

Sample Run:

Anyways:

 

orange.kame.net.

203.178.141.194

2!:0'dig -6 +short www.kame.net'

|interface error

 

Put differently: in the IPv4 DNS system, www.kame.net is currently a CNAME record for orange.kame.net which had the address 203.178.141.194.

 

=={{header|Java}}==

import java.net.Inet4Address;

import java.net.Inet6Address;

}

}

Output:

<pre>

 

=={{header|JavaScript}}==

 

dns.lookup("www.kame.net", {

console.log(addresses);

})

Output:

<pre>

=={{header|Julia}}==

As entered at the REPL command line:

julia> using Sockets

 

ip"2001:200:dff:fff1:216:3eff:feb1:44d7"

 

 

=={{header|Kotlin}}==

 

import java.net.InetAddress

fun main(args: Array<String>) {

showIPAddresses("www.kame.net")

 

{{out}}

=={{header|Lasso}}==

The DNS lookup methods in Lasso do not support IPv6 addresses at this time, only IPv4.

 

=={{header|Lua}}==

{{libheader|LuaSocket}}

 

local ip_tbl = socket.dns.getaddrinfo('www.kame.net')

 

io.write(string.format('%s: %s\n', v.family, v.addr))

end

{{out}}

<pre>

Neko does not yet support ipv6. ipv4 addresses are returned as Int32.

 

var host_resolve = $loader.loadprim("std@host_resolve", 1);

var host_to_string = $loader.loadprim("std@host_to_string", 1);

 

$print("www.kame.net: ", ip, ", ", host_to_string(ip), "\n");

 

{{out}}

 

=={{header|NetRexx}}==

/* NetRexx */

options replace format comments java crossref symbols nobinary

end

end ir

;Output

<pre>

 

=={{header|NewLISP}}==

 

(define (dnsLookup site , ipv)

 

(dnsLookup "www.kame.net")

;Output

<pre>

=={{header|Nim}}==

 

 

iterator items(ai: ptr AddrInfo): ptr AddrInfo =

echo getAddrString i.aiAddr

 

 

{{out}}

{{Works with|oo2c version 2}}

IO:Address module supports only IPv4

MODULE DNSQuery;

IMPORT

Do;

END DNSQuery.

{{Out}}

<pre>

 

=={{header|Objeck}}==

 

class Rosetta {

};

}

 

Output:

=={{header|OCaml}}==

 

let opts = [

Unix.AI_FAMILY ai_family;

Printf.printf " IPv4 address: %s\n" (dns_query host Unix.PF_INET);

Printf.printf " IPv6 address: %s\n" (dns_query host Unix.PF_INET6);

 

=={{header|Perl}}==

use Socket qw(getaddrinfo getnameinfo);

 

die "getaddrinfo error: $err" if $err;

 

{{out}}

<pre>203.178.141.194

Translated from C/MSDN/several man pages.<br>

<b>NB:</b> may warrant further testing, see output.

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">cffi</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">get_name_info</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"www.kame.net"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">WSACleanup</span><span style="color: #0000FF;">()</span>

{{out}}

Note that windows nslookup shows an IPv6 that this does not, whereas

=={{header|PHP}}==

Works for PHP5 (Windows > 5.3.0)

$ipv4_record = dns_get_record("www.kame.net",DNS_A);

$ipv6_record = dns_get_record("www.kame.net",DNS_AAAA);

print "ipv4: " . $ipv4_record[0]["ip"] . "\n";

print "ipv6: " . $ipv6_record[0]["ipv6"] . "\n";

 

=={{header|PicoLisp}}==

(in '(host "www.kame.net")

(while (from "address ")

Output:

<pre>-> ("203.178.141.194" "2001:200:dff:fff1:216:3eff:feb1:44d7")</pre>

=={{header|Pike}}==

 

> array ips = Protocols.DNS.gethostbyname("www.kame.net")[1] || ({});

> write(ips*"\n");

Output:

<pre>203.178.141.194

 

=={{header|PowerShell}}==

 

=={{header|Python}}==

>>> ips = set(i[4][0] for i in socket.getaddrinfo('www.kame.net', 80))

>>> for ip in ips: print ip

...

2001:200:dff:fff1:216:3eff:feb1:44d7

 

=={{header|R}}==

If the following is saved as <tt>dns.cpp</tt>:

 

#include <Rcpp.h>

#include <arpa/inet.h>

 

}

 

It can be used to perform the task in R:

 

library(Rcpp)

sourceCpp("dns.cpp")

## [1] "203.178.141.194"

## [2] "2001:200:dff:fff1:216:3eff:feb1:44d7"

 

=={{header|Racket}}==

The following finds an IPv4 address. Currently, the API does not support returning an IPv6 address.

 

#lang racket

 

(require net/dns)

(dns-get-address "8.8.8.8" "www.kame.net")

 

=={{header|Raku}}==

{{works with|Rakudo|2017.01}}

 

 

my $resolver = Net::DNS.new('8.8.8.8');

 

say $ip4[0].octets.join: '.';

{{out}}

<pre>203.178.141.194

 

Execution note: &nbsp; if the information for &nbsp; &nbsp; '''PING &nbsp; -6 &nbsp; ···''' &nbsp; &nbsp; is blank, you may need to install &nbsp; (on some <br>Microsoft Windows systems) &nbsp; the IPV6 interface using the command: &nbsp; &nbsp; ''' IPV6 &nbsp; install '''

parse arg tar . /*obtain optional domain name from C.L.*/

if tar=='' then tar= 'www.kame.net' /*Not specified? Then use the default.*/

end /*j*/ /* └─◄ force (TEMP) file integrity.*/

/*stick a fork in it, we're all done. */

'''output''' &nbsp; using the default input:

<pre>

 

=={{header|Ruby}}==

=> true

irb(main):002:0> Addrinfo.getaddrinfo("www.kame.net", nil, nil, :DGRAM) \

irb(main):003:0* .map! { |ai| ai.ip_address }

 

=={{header|Rust}}==

 

fn main() {

println!("{}", ip_port.ip());

}

 

Output:<pre>203.178.141.194

=={{header|Scala}}==

{{libheader|Scala}}

 

 

=={{header|Scheme}}==

{{works with|Guile}}

(define n (car (hostent:addr-list (gethost "www.kame.net"))))

 

(display (inet-ntoa n))(newline)

(display (inet-ntop AF_INET n))(newline)

Output:<pre>203.178.141.194

203.178.141.194

The function [http://seed7.sourceforge.net/libraries/socket.htm#numericAddress%28in_socketAddress%29 numericAddress]

is used to get the IP address of the specified host.

include "socket.s7i";

 

begin

writeln(numericAddress(inetSocketAddress("www.kame.net", 1024)));

 

Output:

 

=={{header|Sidef}}==

'www.kame.net', 0,

Hash.new(protocol => Socket.IPPROTO_TCP)

res.each { |z|

say [Socket.getnameinfo(z{:addr}, Socket.NI_NUMERICHOST)][1];

 

{{out}}

=={{header|Standard ML}}==

The basis library provides IPv4 support only:

 

=={{header|Tcl}}==

{{tcllib|dns}}

{{libheader|udp}}

package require dns

 

update; # Let queries complete

}

Output:

<pre>

=={{header|UNIX Shell}}==

===Using dig===

Aamrun ~ % dig www.kame.net A www.kame.net AAAA +short

mango.itojun.org.

2001:2f0:0:8800::1:1

Aamrun ~ %

===Using nslookup===

Aamrun ~ % nslookup

> set q=AAAA

 

Aamrun ~ %

 

=={{header|VBScript}}==

Function dns_query(url,ver)

Set r = New RegExp

 

Call dns_query(WScript.Arguments(0),WScript.Arguments(1))

 

{{Out}}

 

However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to do it for us.

 

class Net {

var host = "orange.kame.net"

var addrs = Net.lookupHost(host).split(", ")

which we embed in the following Go program and run it:

{{libheader|WrenGo}}

 

package main

vm.InterpretFile(fileName)

vm.Free()

 

{{out}}

=={{header|zkl}}==

The addrInfo method is just a front end to POSIX getaddrinfo.