Erlang 21

inet_res




erlang

inet_res

मॉड्यूल

inet_res

मॉड्यूल सारांश

एक अल्पविकसित DNS क्लाइंट।

विवरण

यह मॉड्यूल DNS नाम को पुनरावर्ती नाम सर्वरों के लिए हल करता है।

ERTS User's Guide: Inet Configuration भी देखें ERTS User's Guide: Inet Configuration IP संचार के लिए Erlang रनटाइम सिस्टम को कॉन्फ़िगर करने के तरीके के बारे में अधिक जानकारी के लिए ERTS User's Guide: Inet Configuration , और लुकअप विधि के रूप में 'dns' को परिभाषित करके इस DNS क्लाइंट को कैसे सक्षम करें। DNS क्लाइंट तब inet को हल करने के लिए बैकएंड के रूप में कार्य करता है।

यह DNS क्लाइंट DNS रिकॉर्ड को हल कर सकता है, भले ही इसका उपयोग नोड में सामान्य नाम हल करने के लिए न किया गया हो।

यह एक पूर्ण रिज़ॉल्वर नहीं है, केवल एक DNS क्लाइंट है जो विश्वसनीय पुनरावर्ती नाम सर्वर से पूछने पर निर्भर करता है।

नाम हल करना

यूडीपी प्रश्नों का उपयोग तब तक किया जाता है जब तक कि रिज़ॉल्वर विकल्प का उपयोग true होता true , जो टीसीपी प्रश्नों को मजबूर करता है। यदि क्वेरी UDP के लिए बहुत बड़ी है, तो इसके बजाय TCP का उपयोग किया जाता है। नियमित DNS प्रश्नों के लिए, 512 बाइट्स आकार सीमा है।

जब EDNS सक्षम किया गया है (रिज़ॉल्वर विकल्प edns EDNS संस्करण पर सेट किया गया है (जो कि false बजाय 0 ), तो रिज़ॉल्वर विकल्प udp_payload_size सीमा निर्धारित करता है। यदि कोई नाम सर्वर TC बिट सेट (ट्रंकेशन) के साथ उत्तर देता है, तो यह दर्शाता है कि उत्तर है। अधूरा, क्वेरी टीसीपी का उपयोग करके उस नाम सर्वर से पुनः प्राप्त किया जाता है। रिज़ॉल्वर विकल्प udp_payload_size , अधिकतम अनुमत उत्तर आकार के लिए विज्ञापित आकार भी निर्धारित करता है, यदि EDNS सक्षम है, अन्यथा नाम सर्वर सीमा 512 बाइट्स का उपयोग करता है। यदि उत्तर बड़ा है, तो। एक टीसीपी की अनिवार्यता को समाप्त कर दिया जाता है।

यूडीपी प्रश्नों के लिए, रिज़ॉल्वर विकल्प timeout और retry कंट्रोल रिट्रांसमिशन। nameservers सूची में प्रत्येक नाम सर्वर को टाइम आउट / retry टाइम-आउट के साथ आज़माया जाता है। फिर सभी नाम सर्वरों को फिर से आज़माया जाता है, कुल समय के लिए, टाइम-आउट को दोगुना करना।

search सूची का उपयोग न करने वाले प्रश्नों के लिए, यदि सभी nameservers की क्वेरी के परिणामस्वरूप {error,nxdomain} या एक खाली उत्तर है, तो उसी क्वेरी को alt_nameservers लिए alt_nameservers

रिज़ॉल्वर के प्रकार

निम्न डेटा प्रकार रिज़ॉल्वर की चिंता करते हैं:

जानकारी का प्रकार

res_option() =
{alt_nameservers, [ nameserver() ]} |
{edns, 0 | false} |
{inet6, boolean()} |
{nameservers, [ nameserver() ]} |
{recurse, boolean()} |
{retry, integer()} |
{timeout, integer()} |
{udp_payload_size, integer()} |
{usevc, boolean()}

nameserver() = { inet:ip_address() , Port :: 1..65535}
res_error() =
formerr |
qfmterror |
servfail |
nxdomain |
notimp |
refused |
badvers |
timeout

DNS प्रकार

निम्न डेटा प्रकार DNS क्लाइंट की चिंता करते हैं:

जानकारी का प्रकार

dns_name() = string()

आसन्न डॉट्स के साथ एक स्ट्रिंग।

rr_type() =
a |
aaaa |
cname |
gid |
hinfo |
ns |
mb |
md |
mg |
mf |
minfo |
mx |
naptr |
null |
ptr |
soa |
spf |
srv |
txt |
uid |
uinfo |
unspec |
wks

dns_class() = in | chaos | hs | any
dns_msg() = term()

यह अपारदर्शी डेटा संरचनाओं की एक खोज की शुरुआत है जो कि inet_dns में एक्सेस फ़ंक्शंस के साथ जांच की जा सकती है, जो {Field,Value} inet_dns सूची inet_dns । Arity 2 फ़ंक्शन केवल निर्दिष्ट फ़ील्ड के लिए मान लौटाता है।

dns_msg() = DnsMsg
    inet_dns:msg(DnsMsg) ->
        [ {header, dns_header()}
        | {qdlist, dns_query()}
        | {anlist, dns_rr()}
        | {nslist, dns_rr()}
        | {arlist, dns_rr()} ]
    inet_dns:msg(DnsMsg, header) -> dns_header() % for example
    inet_dns:msg(DnsMsg, Field) -> Value

dns_header() = DnsHeader
    inet_dns:header(DnsHeader) ->
        [ {id, integer()}
        | {qr, boolean()}
        | {opcode, query | iquery | status | integer()}
        | {aa, boolean()}
        | {tc, boolean()}
        | {rd, boolean()}
        | {ra, boolean()}
        | {pr, boolean()}
        | {rcode, integer(0..16)} ]
    inet_dns:header(DnsHeader, Field) -> Value

query_type() = axfr | mailb | maila | any | rr_type()

dns_query() = DnsQuery
    inet_dns:dns_query(DnsQuery) ->
        [ {domain, dns_name()}
        | {type, query_type()}
        | {class, dns_class()} ]
    inet_dns:dns_query(DnsQuery, Field) -> Value

dns_rr() = DnsRr
    inet_dns:rr(DnsRr) -> DnsRrFields | DnsRrOptFields
    DnsRrFields = [ {domain, dns_name()}
                  | {type, rr_type()}
                  | {class, dns_class()}
                  | {ttl, integer()}
                  | {data, dns_data()} ]
    DnsRrOptFields = [ {domain, dns_name()}
                     | {type, opt}
                     | {udp_payload_size, integer()}
                     | {ext_rcode, integer()}
                     | {version, integer()}
                     | {z, integer()}
                     | {data, dns_data()} ]
    inet_dns:rr(DnsRr, Field) -> Value

उपरोक्त प्रकारों के लिए एक सूचना फ़ंक्शन है:

inet_dns:record_type(dns_msg()) -> msg;
inet_dns:record_type(dns_header()) -> header;
inet_dns:record_type(dns_query()) -> dns_query;
inet_dns:record_type(dns_rr()) -> rr;
inet_dns:record_type(_) -> undefined.

तो, inet_dns:(inet_dns:record_type(X))(X) इन डेटा संरचनाओं में से किसी को एक {Field,Value} सूची में परिवर्तित करता है।

dns_data() =
dns_name() |
inet:ip4_address() |
inet:ip6_address() |
{MName :: dns_name() ,
RName :: dns_name() ,
Serial :: integer(),
Refresh :: integer(),
Retry :: integer(),
Expiry :: integer(),
Minimum :: integer()} |
{ inet:ip4_address() , Proto :: integer(), BitMap :: binary()} |
{CpuString :: string(), OsString :: string()} |
{RM :: dns_name() , EM :: dns_name() } |
{Prio :: integer(), dns_name() } |
{Prio :: integer(),
Weight :: integer(),
Port :: integer(),
dns_name() } |
{Order :: integer(),
Preference :: integer(),
Flags :: string(),
Services :: string(),
Regexp :: string(),
dns_name() } |
[string()] |
binary()

Regexp UTF-8 कोडिंग मानक में एन्कोड किए गए वर्णों के साथ एक स्ट्रिंग है।

निर्यात

getbyname (नाम, प्रकार) -> {ठीक है, होस्टेंट} | {त्रुटि, कारण}
getbyname (नाम, प्रकार, समय समाप्त) -> {ठीक है, Hostent} | {त्रुटि, कारण}

प्रकार

वर्ग in , वर्ग के निर्दिष्ट होस्ट के लिए निर्दिष्ट प्रकार का DNS रिकॉर्ड हल करता in । सफलता पर रिटर्न, पता सूची क्षेत्र में dns_data() तत्वों के साथ एक hostent() रिकॉर्ड।

यह फ़ंक्शन रिज़ॉल्वर विकल्प search का उपयोग करता है जो डोमेन नामों की एक सूची है। यदि हल करने के लिए नाम में कोई डॉट्स नहीं हैं, तो यह खोज सूची में प्रत्येक डोमेन नाम से पहले से बना हुआ है, और उन्हें क्रम में रखने की कोशिश की जाती है। यदि नाम में डॉट्स हैं, तो इसे पहले निरपेक्ष नाम के रूप में आज़माया जाता है और यदि वह विफल हो जाता है, तो खोज सूची का उपयोग किया जाता है। यदि नाम में एक अनुगामी बिंदु है, तो इसे एक पूर्ण नाम माना जाता है और खोज सूची का उपयोग नहीं किया जाता है।

gethostbyaddr (पता) -> {ठीक है, होस्टेंट} | {त्रुटि, कारण}
gethostbyaddr (पता, समय समाप्त) -> {ठीक है, होस्टेंट} | {त्रुटि, कारण}

प्रकार

Inet द्वारा उपयोग किए जाने वाले बैकएंड फ़ंक्शन inet:gethostbyaddr/1

gethostbyname (नाम) -> {ठीक है, Hostent} | {त्रुटि, कारण}
gethostbyname (नाम, परिवार) -> {ठीक है, होस्टेंट} | {त्रुटि, कारण}
gethostbyname (नाम, परिवार, समय समाप्त) ->
{ओके, होस्टेंट} | {त्रुटि, कारण}

प्रकार

Inet द्वारा उपयोग किए जाने वाले बैकएंड फ़ंक्शन inet:gethostbyname/1,2

यह फ़ंक्शन getbyname/2,3 तरह रिज़ॉल्वर विकल्प search का उपयोग करता है।

यदि inet6 में inet6 विकल्प true , तो IPv6 एड्रेस देखा जाता है।

लुकअप (नाम, कक्षा, प्रकार) -> [ dns_data() ]
लुकअप (नाम, कक्षा, प्रकार, विकल्प) -> [ dns_data() ]
लुकअप (नाम, वर्ग, प्रकार, dns_data() , टाइमआउट) -> [ dns_data() ]

प्रकार

निर्दिष्ट नाम के लिए निर्दिष्ट प्रकार और वर्ग के रिकॉर्ड के लिए DNS डेटा को हल करता है। सफलता पर, सही Class और Type साथ उत्तर रिकॉर्ड को फ़िल्टर करता है, और उनके डेटा फ़ील्ड की एक सूची देता है। तो, any प्रकार के लिए एक खोज एक खाली उत्तर देता है, क्योंकि उत्तर रिकॉर्ड में विशिष्ट प्रकार होते हैं जो कोई any नहीं है। एक खाली उत्तर या एक असफल लुकअप एक खाली सूची देता है।

कॉल उसी तर्क के साथ resolve/* करते हैं और परिणाम को फ़िल्टर करते हैं, इसलिए उन कार्यों के लिए Opts का वर्णन किया जाता है।

समाधान (नाम, वर्ग, प्रकार) -> {ठीक है, dns_msg() } | त्रुटि
समाधान (नाम, वर्ग, प्रकार, विकल्प) -> {ठीक है, dns_msg() } | त्रुटि
समाधान (नाम, वर्ग, प्रकार, विकल्प, समय समाप्त) ->
{ठीक है, dns_msg() } | त्रुटि

प्रकार

निर्दिष्ट नाम के लिए निर्दिष्ट प्रकार और वर्ग का DNS रिकॉर्ड हल करता है। DNS Types में अनुभाग में वर्णित के रूप में, inet_db में एक्सेस फ़ंक्शंस का उपयोग करके लौटे dns_msg() की जांच की जा सकती है।

यदि Name एक ip_address() , तो मानक रिवर्स के रूप में क्वेरी करने के लिए डोमेन नाम ".IN-ADDR.ARPA." IPv4 पते के लिए नाम, या ".IP6.ARPA." IPv6 पते के लिए नाम। इस स्थिति में, आप शायद Class = in और Type = ptr का उपयोग करना चाहते हैं, लेकिन यह स्वचालित रूप से नहीं किया जाता है।

Opts इसी रिवाल्वर विकल्पों को ओवरराइड करता है। यदि विकल्प nameservers निर्दिष्ट किया जाता है, तो यह माना जाता है कि यह नाम alt_nameserves की पूरी सूची है, इसलिए रिज़ॉल्वर विकल्प alt_nameserves की उपेक्षा की जाती है। हालाँकि, अगर alt_nameserves विकल्प भी इस फ़ंक्शन के लिए निर्दिष्ट है, तो इसका उपयोग किया जाता है।

विकल्प verbose (या बल्कि {verbose,true} ) io:format/2 माध्यम से डायग्नोस्टिक्स प्रिंटआउट का कारण बनता है io:format/2 प्रश्नों के io:format/2 , उत्तर पुनरावृत्ति, और इसी तरह, यूटिलिटी से dig और nslookup

यदि Opt कोई परमाणु है, तो इसे {Opt,true} रूप में व्याख्या किया जाता है जब तक कि परमाणु स्ट्रिंग "no" साथ शुरू होता है, जिससे व्याख्या {Opt,false} । उदाहरण के लिए, उपयोग usevc {usevc,true} लिए एक उपनाम है {usevc,true} और nousevc {usevc,false} लिए एक उपनाम है, उपयोग के लिए {usevc,false}

विकल्प inet6 का इस फ़ंक्शन पर कोई प्रभाव नहीं है। आप शायद Type = a | aaaa इसके बजाय Type = a | aaaa

उदाहरण

यह एक्सेस फ़ंक्शंस उदाहरण दिखाता है कि मॉड्यूल के बाहर से resolve/* का उपयोग करके lookup/3 को कैसे लागू किया जा सकता है:

example_lookup(Name, Class, Type) ->
    case inet_res:resolve(Name, Class, Type) of
        {ok,Msg} ->
            [inet_dns:rr(RR, data)
             || RR <- inet_dns:msg(Msg, anlist),
                 inet_dns:rr(RR, type) =:= Type,
                 inet_dns:rr(RR, class) =:= Class];
        {error,_} ->
            []
     end.

विरासत के कार्य

नाम सर्वर / टाइम-आउट तर्क के कष्टप्रद दोहरे अर्थ के कारण इन्हें हटा दिया जाता है, और क्योंकि उनके पास रिज़ॉल्वर विकल्प सूची के लिए कोई सभ्य स्थान नहीं है।

निर्यात

nslookup (नाम, वर्ग, प्रकार) -> {ठीक है, dns_msg() } | {त्रुटि, कारण}
nslookup (नाम, वर्ग, प्रकार, समय समाप्त) ->
{ठीक है, dns_msg() } | {त्रुटि, कारण}
nslookup (नाम, वर्ग, प्रकार, नामकरण) ->
{ठीक है, dns_msg() } | {त्रुटि, कारण}

प्रकार

निर्दिष्ट नाम के लिए निर्दिष्ट प्रकार और वर्ग का DNS रिकॉर्ड हल करता है।

nnslookup (नाम, वर्ग, प्रकार, नामकरण) ->
{ठीक है, dns_msg() } | {त्रुटि, कारण}
nnslookup (नाम, वर्ग, प्रकार, नामकरण, समय समाप्त) ->
{ठीक है, dns_msg() } | {त्रुटि, कारण}

प्रकार

निर्दिष्ट नाम के लिए निर्दिष्ट प्रकार और वर्ग का DNS रिकॉर्ड हल करता है।