typenative 0.4.0 → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/workflows/ci.yml +2 -0
- package/CHANGELOG.md +201 -0
- package/CONTRIBUTION.md +1 -1
- package/bin/cli.js +1 -0
- package/bin/go/bridge.js +74 -14
- package/bin/go/convert.js +48 -0
- package/bin/go/metadata.js +13 -4
- package/bin/go/overrides.js +4 -6
- package/bin/go/stdlib.generated.js +2 -0
- package/bin/index.js +117 -0
- package/bin/main.js +1 -0
- package/bin/node/child_process.js +51 -3
- package/bin/node/cluster.js +41 -3
- package/bin/node/core.js +1 -1
- package/bin/node/crypto.js +205 -4
- package/bin/node/dgram.js +230 -6
- package/bin/node/dns.js +470 -7
- package/bin/node/errno_tables.js +445 -0
- package/bin/node/fs.js +21 -14
- package/bin/node/http.js +128 -30
- package/bin/node/http2.js +4 -1
- package/bin/node/module_v8.js +142 -0
- package/bin/node/net.js +9 -6
- package/bin/node/process.js +242 -0
- package/bin/node/readline.js +271 -0
- package/bin/node/registry.js +2 -1
- package/bin/node/sqlite.js +60 -12
- package/bin/node/stream.js +139 -7
- package/bin/node/test.js +311 -19
- package/bin/node/url.js +23 -5
- package/bin/node/util.js +18 -1
- package/bin/node/util_extra.js +6 -30
- package/bin/node/worker_threads.js +79 -19
- package/bin/transpiler.js +4019 -497
- package/bin/typecheck-node.js +1 -0
- package/bin/version.js +1 -1
- package/conformance.md +1025 -884
- package/examples/README.md +5 -5
- package/examples/json-server/README.md +31 -29
- package/examples/json-server/bench.mjs +130 -38
- package/package.json +1 -1
- package/types/typenative-go.d.ts +23 -0
- package/types/typenative-npm.d.ts +169 -5
- package/types/typenative.d.ts +185 -11
package/bin/node/dns.js
CHANGED
|
@@ -176,6 +176,7 @@ type TnDnsResolver struct {
|
|
|
176
176
|
mu sync.Mutex
|
|
177
177
|
servers []string
|
|
178
178
|
timeout time.Duration
|
|
179
|
+
tries int
|
|
179
180
|
local4 net.IP
|
|
180
181
|
local6 net.IP
|
|
181
182
|
next uint32
|
|
@@ -196,6 +197,9 @@ func TnNewDnsResolver(options ...interface{}) *TnDnsResolver {
|
|
|
196
197
|
if ms, ok := tnNetNumber(TnGet(options[0], "timeout")); ok && ms > 0 {
|
|
197
198
|
r.timeout = time.Duration(ms) * time.Millisecond
|
|
198
199
|
}
|
|
200
|
+
if n, ok := tnNetNumber(TnGet(options[0], "tries")); ok && n > 0 {
|
|
201
|
+
r.tries = int(n)
|
|
202
|
+
}
|
|
199
203
|
}
|
|
200
204
|
return r
|
|
201
205
|
}
|
|
@@ -515,6 +519,440 @@ func TnDnsGetServers() []string {
|
|
|
515
519
|
}
|
|
516
520
|
}
|
|
517
521
|
return out
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
// Raw DNS queries (golang.org/x/net/dns/dnsmessage, copied from GOROOT) for
|
|
525
|
+
// what Go's resolver hides: TTLs, ANY / CAA / NAPTR / PTR / SOA records
|
|
526
|
+
type TnRecordWithTtl struct {
|
|
527
|
+
address string
|
|
528
|
+
ttl float64
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
type TnSoaRecord struct {
|
|
532
|
+
nsname string
|
|
533
|
+
hostmaster string
|
|
534
|
+
serial float64
|
|
535
|
+
refresh float64
|
|
536
|
+
retry float64
|
|
537
|
+
expire float64
|
|
538
|
+
minttl float64
|
|
539
|
+
}
|
|
540
|
+
|
|
541
|
+
type TnNaptrRecord struct {
|
|
542
|
+
flags string
|
|
543
|
+
service string
|
|
544
|
+
regexp string
|
|
545
|
+
replacement string
|
|
546
|
+
order float64
|
|
547
|
+
preference float64
|
|
548
|
+
}
|
|
549
|
+
|
|
550
|
+
func (r *TnDnsResolver) queryError(code string, syscallName string, hostname string) *TnError {
|
|
551
|
+
e := TnNodeError("Error", code, syscallName+" "+code+" "+hostname)
|
|
552
|
+
e.props["syscall"] = syscallName
|
|
553
|
+
e.props["hostname"] = hostname
|
|
554
|
+
return e
|
|
555
|
+
}
|
|
556
|
+
|
|
557
|
+
// One exchange with a server: UDP, then TCP when the answer is truncated
|
|
558
|
+
func tnDnsExchange(ctx context.Context, server string, local net.IP, query []byte, id uint16) (*dnsmessage.Message, error) {
|
|
559
|
+
for _, network := range []string{"udp", "tcp"} {
|
|
560
|
+
d := net.Dialer{}
|
|
561
|
+
if local != nil {
|
|
562
|
+
if network == "udp" {
|
|
563
|
+
d.LocalAddr = &net.UDPAddr{IP: local}
|
|
564
|
+
} else {
|
|
565
|
+
d.LocalAddr = &net.TCPAddr{IP: local}
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
conn, err := d.DialContext(ctx, network, server)
|
|
569
|
+
if err != nil {
|
|
570
|
+
return nil, err
|
|
571
|
+
}
|
|
572
|
+
stop := context.AfterFunc(ctx, func() { conn.SetDeadline(time.Now()) })
|
|
573
|
+
var answer []byte
|
|
574
|
+
if network == "udp" {
|
|
575
|
+
_, err = conn.Write(query)
|
|
576
|
+
buf := make([]byte, 65535)
|
|
577
|
+
for err == nil {
|
|
578
|
+
var n int
|
|
579
|
+
n, err = conn.Read(buf)
|
|
580
|
+
// skip stray answers to other queries
|
|
581
|
+
if err == nil && n >= 2 && uint16(buf[0])<<8|uint16(buf[1]) == id {
|
|
582
|
+
answer = buf[:n]
|
|
583
|
+
break
|
|
584
|
+
}
|
|
585
|
+
}
|
|
586
|
+
} else {
|
|
587
|
+
framed := append([]byte{byte(len(query) >> 8), byte(len(query))}, query...)
|
|
588
|
+
if _, err = conn.Write(framed); err == nil {
|
|
589
|
+
header := make([]byte, 2)
|
|
590
|
+
if _, err = io.ReadFull(conn, header); err == nil {
|
|
591
|
+
answer = make([]byte, int(header[0])<<8|int(header[1]))
|
|
592
|
+
_, err = io.ReadFull(conn, answer)
|
|
593
|
+
}
|
|
594
|
+
}
|
|
595
|
+
}
|
|
596
|
+
stop()
|
|
597
|
+
conn.Close()
|
|
598
|
+
if err != nil {
|
|
599
|
+
return nil, err
|
|
600
|
+
}
|
|
601
|
+
var msg dnsmessage.Message
|
|
602
|
+
if err := msg.Unpack(answer); err != nil {
|
|
603
|
+
return nil, err
|
|
604
|
+
}
|
|
605
|
+
if msg.Truncated && network == "udp" {
|
|
606
|
+
continue
|
|
607
|
+
}
|
|
608
|
+
return &msg, nil
|
|
609
|
+
}
|
|
610
|
+
return nil, errors.New("truncated")
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
// rawQuery(name, type): the answers of that type (all of them for ANY), trying
|
|
614
|
+
// each server in turn, tries times (Node's c-ares defaults: 5 s, 4 tries)
|
|
615
|
+
func (r *TnDnsResolver) rawQuery(hostname string, qtype dnsmessage.Type, syscallName string) ([]dnsmessage.Resource, error) {
|
|
616
|
+
r.mu.Lock()
|
|
617
|
+
if r.ctx == nil {
|
|
618
|
+
r.ctx, r.stop = context.WithCancel(context.Background())
|
|
619
|
+
}
|
|
620
|
+
parent := r.ctx
|
|
621
|
+
servers := append([]string{}, r.servers...)
|
|
622
|
+
local4, local6 := r.local4, r.local6
|
|
623
|
+
timeout, tries := r.timeout, r.tries
|
|
624
|
+
r.mu.Unlock()
|
|
625
|
+
if len(servers) == 0 {
|
|
626
|
+
for _, s := range TnDnsGetServers() {
|
|
627
|
+
if addr, err := netip.ParseAddr(s); err == nil {
|
|
628
|
+
servers = append(servers, netip.AddrPortFrom(addr, 53).String())
|
|
629
|
+
}
|
|
630
|
+
}
|
|
631
|
+
}
|
|
632
|
+
if len(servers) == 0 {
|
|
633
|
+
servers = []string{"127.0.0.1:53"}
|
|
634
|
+
}
|
|
635
|
+
if timeout <= 0 {
|
|
636
|
+
timeout = 5 * time.Second
|
|
637
|
+
}
|
|
638
|
+
if tries <= 0 {
|
|
639
|
+
tries = 4
|
|
640
|
+
}
|
|
641
|
+
fqdn := hostname
|
|
642
|
+
if !strings.HasSuffix(fqdn, ".") {
|
|
643
|
+
fqdn += "."
|
|
644
|
+
}
|
|
645
|
+
name, err := dnsmessage.NewName(fqdn)
|
|
646
|
+
if err != nil {
|
|
647
|
+
return nil, r.queryError("EBADNAME", syscallName, hostname)
|
|
648
|
+
}
|
|
649
|
+
id := uint16(time.Now().UnixNano())
|
|
650
|
+
b := dnsmessage.NewBuilder(nil, dnsmessage.Header{ID: id, RecursionDesired: true})
|
|
651
|
+
b.EnableCompression()
|
|
652
|
+
b.StartQuestions()
|
|
653
|
+
b.Question(dnsmessage.Question{Name: name, Type: qtype, Class: dnsmessage.ClassINET})
|
|
654
|
+
b.StartAdditionals()
|
|
655
|
+
var opt dnsmessage.ResourceHeader
|
|
656
|
+
opt.SetEDNS0(1232, dnsmessage.RCodeSuccess, false)
|
|
657
|
+
b.OPTResource(opt, dnsmessage.OPTResource{})
|
|
658
|
+
query, err := b.Finish()
|
|
659
|
+
if err != nil {
|
|
660
|
+
return nil, r.queryError("EBADQUERY", syscallName, hostname)
|
|
661
|
+
}
|
|
662
|
+
code := "ECONNREFUSED"
|
|
663
|
+
for try := 0; try < tries; try++ {
|
|
664
|
+
for _, server := range servers {
|
|
665
|
+
if parent.Err() != nil {
|
|
666
|
+
return nil, r.queryError("ECANCELLED", syscallName, hostname)
|
|
667
|
+
}
|
|
668
|
+
local := local4
|
|
669
|
+
if ap, err := netip.ParseAddrPort(server); err == nil && ap.Addr().Is6() {
|
|
670
|
+
local = local6
|
|
671
|
+
}
|
|
672
|
+
ctx, done := context.WithTimeout(parent, timeout)
|
|
673
|
+
msg, err := tnDnsExchange(ctx, server, local, query, id)
|
|
674
|
+
timedOut := ctx.Err() == context.DeadlineExceeded
|
|
675
|
+
done()
|
|
676
|
+
if err != nil {
|
|
677
|
+
if parent.Err() != nil {
|
|
678
|
+
return nil, r.queryError("ECANCELLED", syscallName, hostname)
|
|
679
|
+
}
|
|
680
|
+
if timedOut {
|
|
681
|
+
code = "ETIMEOUT"
|
|
682
|
+
}
|
|
683
|
+
continue
|
|
684
|
+
}
|
|
685
|
+
switch msg.RCode {
|
|
686
|
+
case dnsmessage.RCodeSuccess:
|
|
687
|
+
case dnsmessage.RCodeNameError:
|
|
688
|
+
return nil, r.queryError("ENOTFOUND", syscallName, hostname)
|
|
689
|
+
case dnsmessage.RCodeServerFailure:
|
|
690
|
+
code = "ESERVFAIL"
|
|
691
|
+
continue
|
|
692
|
+
case dnsmessage.RCodeRefused:
|
|
693
|
+
code = "EREFUSED"
|
|
694
|
+
continue
|
|
695
|
+
case dnsmessage.RCodeNotImplemented:
|
|
696
|
+
return nil, r.queryError("ENOTIMP", syscallName, hostname)
|
|
697
|
+
default:
|
|
698
|
+
return nil, r.queryError("EFORMERR", syscallName, hostname)
|
|
699
|
+
}
|
|
700
|
+
answers := []dnsmessage.Resource{}
|
|
701
|
+
for _, a := range msg.Answers {
|
|
702
|
+
if qtype == dnsmessage.TypeALL || a.Header.Type == qtype {
|
|
703
|
+
answers = append(answers, a)
|
|
704
|
+
}
|
|
705
|
+
}
|
|
706
|
+
if len(answers) == 0 {
|
|
707
|
+
return nil, r.queryError("ENODATA", syscallName, hostname)
|
|
708
|
+
}
|
|
709
|
+
return answers, nil
|
|
710
|
+
}
|
|
711
|
+
}
|
|
712
|
+
return nil, r.queryError(code, syscallName, hostname)
|
|
713
|
+
}
|
|
714
|
+
|
|
715
|
+
func tnDnsName(n dnsmessage.Name) string {
|
|
716
|
+
return strings.TrimSuffix(n.String(), ".")
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
// <character-string>s and an uncompressed name, for NAPTR and CAA
|
|
720
|
+
func tnDnsCharString(data []byte, i *int) string {
|
|
721
|
+
if *i >= len(data) {
|
|
722
|
+
return ""
|
|
723
|
+
}
|
|
724
|
+
n := int(data[*i])
|
|
725
|
+
end := *i + 1 + n
|
|
726
|
+
if end > len(data) {
|
|
727
|
+
end = len(data)
|
|
728
|
+
}
|
|
729
|
+
s := string(data[*i+1 : end])
|
|
730
|
+
*i = end
|
|
731
|
+
return s
|
|
732
|
+
}
|
|
733
|
+
|
|
734
|
+
func tnDnsWireName(data []byte, i int) string {
|
|
735
|
+
labels := []string{}
|
|
736
|
+
for i < len(data) && data[i] != 0 {
|
|
737
|
+
n := int(data[i])
|
|
738
|
+
if i+1+n > len(data) {
|
|
739
|
+
break
|
|
740
|
+
}
|
|
741
|
+
labels = append(labels, string(data[i+1:i+1+n]))
|
|
742
|
+
i += 1 + n
|
|
743
|
+
}
|
|
744
|
+
return strings.Join(labels, ".")
|
|
745
|
+
}
|
|
746
|
+
|
|
747
|
+
func tnNaptrRecord(data []byte) *TnNaptrRecord {
|
|
748
|
+
rec := &TnNaptrRecord{}
|
|
749
|
+
if len(data) < 4 {
|
|
750
|
+
return rec
|
|
751
|
+
}
|
|
752
|
+
rec.order = float64(int(data[0])<<8 | int(data[1]))
|
|
753
|
+
rec.preference = float64(int(data[2])<<8 | int(data[3]))
|
|
754
|
+
i := 4
|
|
755
|
+
rec.flags = tnDnsCharString(data, &i)
|
|
756
|
+
rec.service = tnDnsCharString(data, &i)
|
|
757
|
+
rec.regexp = tnDnsCharString(data, &i)
|
|
758
|
+
rec.replacement = tnDnsWireName(data, i)
|
|
759
|
+
return rec
|
|
760
|
+
}
|
|
761
|
+
|
|
762
|
+
// CAA: { critical, <tag>: value }
|
|
763
|
+
func tnCaaRecord(data []byte) *TnMap[string, interface{}] {
|
|
764
|
+
m := TnNewMap[string, interface{}]()
|
|
765
|
+
if len(data) < 2 {
|
|
766
|
+
return m
|
|
767
|
+
}
|
|
768
|
+
m.Set("critical", float64(data[0]))
|
|
769
|
+
n := int(data[1])
|
|
770
|
+
if 2+n > len(data) {
|
|
771
|
+
return m
|
|
772
|
+
}
|
|
773
|
+
m.Set(string(data[2:2+n]), string(data[2+n:]))
|
|
774
|
+
return m
|
|
775
|
+
}
|
|
776
|
+
|
|
777
|
+
func tnSoaRecord(b *dnsmessage.SOAResource) *TnSoaRecord {
|
|
778
|
+
return &TnSoaRecord{
|
|
779
|
+
nsname: tnDnsName(b.NS), hostmaster: tnDnsName(b.MBox), serial: float64(b.Serial),
|
|
780
|
+
refresh: float64(b.Refresh), retry: float64(b.Retry), expire: float64(b.Expire), minttl: float64(b.MinTTL),
|
|
781
|
+
}
|
|
782
|
+
}
|
|
783
|
+
|
|
784
|
+
// resolveAny: each record with its type, in Node's shape
|
|
785
|
+
func tnAnyRecord(rr dnsmessage.Resource) interface{} {
|
|
786
|
+
m := TnNewMap[string, interface{}]()
|
|
787
|
+
ttl := float64(rr.Header.TTL)
|
|
788
|
+
switch b := rr.Body.(type) {
|
|
789
|
+
case *dnsmessage.AResource:
|
|
790
|
+
m.Set("address", net.IP(b.A[:]).String())
|
|
791
|
+
m.Set("ttl", ttl)
|
|
792
|
+
m.Set("type", "A")
|
|
793
|
+
case *dnsmessage.AAAAResource:
|
|
794
|
+
m.Set("address", net.IP(b.AAAA[:]).String())
|
|
795
|
+
m.Set("ttl", ttl)
|
|
796
|
+
m.Set("type", "AAAA")
|
|
797
|
+
case *dnsmessage.CNAMEResource:
|
|
798
|
+
m.Set("value", tnDnsName(b.CNAME))
|
|
799
|
+
m.Set("type", "CNAME")
|
|
800
|
+
case *dnsmessage.MXResource:
|
|
801
|
+
m.Set("exchange", tnDnsName(b.MX))
|
|
802
|
+
m.Set("priority", float64(b.Pref))
|
|
803
|
+
m.Set("type", "MX")
|
|
804
|
+
case *dnsmessage.NSResource:
|
|
805
|
+
m.Set("value", tnDnsName(b.NS))
|
|
806
|
+
m.Set("type", "NS")
|
|
807
|
+
case *dnsmessage.PTRResource:
|
|
808
|
+
m.Set("value", tnDnsName(b.PTR))
|
|
809
|
+
m.Set("type", "PTR")
|
|
810
|
+
case *dnsmessage.SOAResource:
|
|
811
|
+
s := tnSoaRecord(b)
|
|
812
|
+
m.Set("nsname", s.nsname)
|
|
813
|
+
m.Set("hostmaster", s.hostmaster)
|
|
814
|
+
m.Set("serial", s.serial)
|
|
815
|
+
m.Set("refresh", s.refresh)
|
|
816
|
+
m.Set("retry", s.retry)
|
|
817
|
+
m.Set("expire", s.expire)
|
|
818
|
+
m.Set("minttl", s.minttl)
|
|
819
|
+
m.Set("type", "SOA")
|
|
820
|
+
case *dnsmessage.TXTResource:
|
|
821
|
+
m.Set("entries", append([]string{}, b.TXT...))
|
|
822
|
+
m.Set("type", "TXT")
|
|
823
|
+
case *dnsmessage.SRVResource:
|
|
824
|
+
m.Set("priority", float64(b.Priority))
|
|
825
|
+
m.Set("weight", float64(b.Weight))
|
|
826
|
+
m.Set("port", float64(b.Port))
|
|
827
|
+
m.Set("name", tnDnsName(b.Target))
|
|
828
|
+
m.Set("type", "SRV")
|
|
829
|
+
case *dnsmessage.UnknownResource:
|
|
830
|
+
switch rr.Header.Type {
|
|
831
|
+
case 35:
|
|
832
|
+
n := tnNaptrRecord(b.Data)
|
|
833
|
+
m.Set("flags", n.flags)
|
|
834
|
+
m.Set("service", n.service)
|
|
835
|
+
m.Set("regexp", n.regexp)
|
|
836
|
+
m.Set("replacement", n.replacement)
|
|
837
|
+
m.Set("order", n.order)
|
|
838
|
+
m.Set("preference", n.preference)
|
|
839
|
+
m.Set("type", "NAPTR")
|
|
840
|
+
case 257:
|
|
841
|
+
caa := tnCaaRecord(b.Data)
|
|
842
|
+
caa.Set("type", "CAA")
|
|
843
|
+
return caa
|
|
844
|
+
default:
|
|
845
|
+
return nil
|
|
846
|
+
}
|
|
847
|
+
default:
|
|
848
|
+
return nil
|
|
849
|
+
}
|
|
850
|
+
return m
|
|
851
|
+
}
|
|
852
|
+
|
|
853
|
+
func (r *TnDnsResolver) resolveAny(hostname string) ([]interface{}, error) {
|
|
854
|
+
answers, err := r.rawQuery(hostname, dnsmessage.TypeALL, "queryAny")
|
|
855
|
+
if err != nil {
|
|
856
|
+
return nil, err
|
|
857
|
+
}
|
|
858
|
+
// grouped by type in Node's order
|
|
859
|
+
out := []interface{}{}
|
|
860
|
+
for _, t := range []dnsmessage.Type{dnsmessage.TypeA, dnsmessage.TypeCNAME, dnsmessage.TypeAAAA, dnsmessage.TypeMX, dnsmessage.TypeNS, dnsmessage.TypeTXT, dnsmessage.TypeSRV, dnsmessage.TypePTR, 35, dnsmessage.TypeSOA, 257} {
|
|
861
|
+
for _, a := range answers {
|
|
862
|
+
if a.Header.Type != t {
|
|
863
|
+
continue
|
|
864
|
+
}
|
|
865
|
+
if rec := tnAnyRecord(a); rec != nil {
|
|
866
|
+
out = append(out, rec)
|
|
867
|
+
}
|
|
868
|
+
}
|
|
869
|
+
}
|
|
870
|
+
return out, nil
|
|
871
|
+
}
|
|
872
|
+
|
|
873
|
+
func (r *TnDnsResolver) resolveCaa(hostname string) ([]interface{}, error) {
|
|
874
|
+
answers, err := r.rawQuery(hostname, dnsmessage.Type(257), "queryCaa")
|
|
875
|
+
if err != nil {
|
|
876
|
+
return nil, err
|
|
877
|
+
}
|
|
878
|
+
out := []interface{}{}
|
|
879
|
+
for _, a := range answers {
|
|
880
|
+
if u, ok := a.Body.(*dnsmessage.UnknownResource); ok {
|
|
881
|
+
out = append(out, tnCaaRecord(u.Data))
|
|
882
|
+
}
|
|
883
|
+
}
|
|
884
|
+
return out, nil
|
|
885
|
+
}
|
|
886
|
+
|
|
887
|
+
func (r *TnDnsResolver) resolveNaptr(hostname string) ([]*TnNaptrRecord, error) {
|
|
888
|
+
answers, err := r.rawQuery(hostname, dnsmessage.Type(35), "queryNaptr")
|
|
889
|
+
if err != nil {
|
|
890
|
+
return nil, err
|
|
891
|
+
}
|
|
892
|
+
out := []*TnNaptrRecord{}
|
|
893
|
+
for _, a := range answers {
|
|
894
|
+
if u, ok := a.Body.(*dnsmessage.UnknownResource); ok {
|
|
895
|
+
out = append(out, tnNaptrRecord(u.Data))
|
|
896
|
+
}
|
|
897
|
+
}
|
|
898
|
+
return out, nil
|
|
899
|
+
}
|
|
900
|
+
|
|
901
|
+
func (r *TnDnsResolver) resolvePtr(hostname string) ([]string, error) {
|
|
902
|
+
answers, err := r.rawQuery(hostname, dnsmessage.TypePTR, "queryPtr")
|
|
903
|
+
if err != nil {
|
|
904
|
+
return nil, err
|
|
905
|
+
}
|
|
906
|
+
out := []string{}
|
|
907
|
+
for _, a := range answers {
|
|
908
|
+
if b, ok := a.Body.(*dnsmessage.PTRResource); ok {
|
|
909
|
+
out = append(out, tnDnsName(b.PTR))
|
|
910
|
+
}
|
|
911
|
+
}
|
|
912
|
+
return out, nil
|
|
913
|
+
}
|
|
914
|
+
|
|
915
|
+
func (r *TnDnsResolver) resolveSoa(hostname string) (*TnSoaRecord, error) {
|
|
916
|
+
answers, err := r.rawQuery(hostname, dnsmessage.TypeSOA, "querySoa")
|
|
917
|
+
if err != nil {
|
|
918
|
+
return nil, err
|
|
919
|
+
}
|
|
920
|
+
for _, a := range answers {
|
|
921
|
+
if b, ok := a.Body.(*dnsmessage.SOAResource); ok {
|
|
922
|
+
return tnSoaRecord(b), nil
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
return nil, r.queryError("ENODATA", "querySoa", hostname)
|
|
926
|
+
}
|
|
927
|
+
|
|
928
|
+
// resolve4 / resolve6 with { ttl: true }
|
|
929
|
+
func (r *TnDnsResolver) resolveTtl(hostname string, family int) ([]*TnRecordWithTtl, error) {
|
|
930
|
+
qtype, syscallName := dnsmessage.TypeA, "queryA"
|
|
931
|
+
if family == 6 {
|
|
932
|
+
qtype, syscallName = dnsmessage.TypeAAAA, "queryAaaa"
|
|
933
|
+
}
|
|
934
|
+
answers, err := r.rawQuery(hostname, qtype, syscallName)
|
|
935
|
+
if err != nil {
|
|
936
|
+
return nil, err
|
|
937
|
+
}
|
|
938
|
+
out := []*TnRecordWithTtl{}
|
|
939
|
+
for _, a := range answers {
|
|
940
|
+
switch b := a.Body.(type) {
|
|
941
|
+
case *dnsmessage.AResource:
|
|
942
|
+
out = append(out, &TnRecordWithTtl{address: net.IP(b.A[:]).String(), ttl: float64(a.Header.TTL)})
|
|
943
|
+
case *dnsmessage.AAAAResource:
|
|
944
|
+
out = append(out, &TnRecordWithTtl{address: net.IP(b.AAAA[:]).String(), ttl: float64(a.Header.TTL)})
|
|
945
|
+
}
|
|
946
|
+
}
|
|
947
|
+
return out, nil
|
|
948
|
+
}
|
|
949
|
+
|
|
950
|
+
func (r *TnDnsResolver) resolve4Ttl(hostname string) ([]*TnRecordWithTtl, error) {
|
|
951
|
+
return r.resolveTtl(hostname, 4)
|
|
952
|
+
}
|
|
953
|
+
|
|
954
|
+
func (r *TnDnsResolver) resolve6Ttl(hostname string) ([]*TnRecordWithTtl, error) {
|
|
955
|
+
return r.resolveTtl(hostname, 6)
|
|
518
956
|
}`;
|
|
519
957
|
const RESOLVERS = {
|
|
520
958
|
resolve4: '[]string',
|
|
@@ -524,7 +962,14 @@ const RESOLVERS = {
|
|
|
524
962
|
resolveTxt: '[][]string',
|
|
525
963
|
resolveNs: '[]string',
|
|
526
964
|
resolveSrv: '[]*TnSrvRecord',
|
|
527
|
-
reverse: '[]string'
|
|
965
|
+
reverse: '[]string',
|
|
966
|
+
resolveAny: '[]interface{}',
|
|
967
|
+
resolveCaa: '[]interface{}',
|
|
968
|
+
resolveNaptr: '[]*TnNaptrRecord',
|
|
969
|
+
resolvePtr: '[]string',
|
|
970
|
+
resolveSoa: '*TnSoaRecord',
|
|
971
|
+
resolve4Ttl: '[]*TnRecordWithTtl',
|
|
972
|
+
resolve6Ttl: '[]*TnRecordWithTtl'
|
|
528
973
|
};
|
|
529
974
|
// dns.resolve(hostname, rrtype) → the resolve function for the record type
|
|
530
975
|
const RRTYPES = {
|
|
@@ -535,8 +980,20 @@ const RRTYPES = {
|
|
|
535
980
|
TXT: 'resolveTxt',
|
|
536
981
|
NS: 'resolveNs',
|
|
537
982
|
SRV: 'resolveSrv',
|
|
538
|
-
PTR: '
|
|
983
|
+
PTR: 'resolvePtr',
|
|
984
|
+
ANY: 'resolveAny',
|
|
985
|
+
CAA: 'resolveCaa',
|
|
986
|
+
NAPTR: 'resolveNaptr',
|
|
987
|
+
SOA: 'resolveSoa'
|
|
539
988
|
};
|
|
989
|
+
// resolve4 / resolve6 with { ttl: true } return { address, ttl } records
|
|
990
|
+
function withTtl(fn, nodes) {
|
|
991
|
+
const options = nodes[1];
|
|
992
|
+
if (!options || options.kind !== 'ObjectLiteralExpression')
|
|
993
|
+
return fn;
|
|
994
|
+
const ttl = getOption(options, 'ttl');
|
|
995
|
+
return ttl && ttl.kind === 'TrueKeyword' ? `${fn}Ttl` : fn;
|
|
996
|
+
}
|
|
540
997
|
function lookupAll(nodes) {
|
|
541
998
|
const options = nodes[1];
|
|
542
999
|
if (!options || options.kind !== 'ObjectLiteralExpression')
|
|
@@ -554,11 +1011,14 @@ export function registerDns(r) {
|
|
|
554
1011
|
defineModule(r, 'dns');
|
|
555
1012
|
defineModule(r, 'dns/promises');
|
|
556
1013
|
r.namespaces['dns.promises'] = 'dns/promises';
|
|
557
|
-
defineHelper(r, 'nodeDns', ['context', 'net', 'net/netip', 'os', 'strconv', 'strings', 'sync', 'sync/atomic', 'time'], ['nodeNet', 'netErrors', 'eventLoop', 'promise', 'nodeInvoke', 'dynamic'], dnsHelper);
|
|
1014
|
+
defineHelper(r, 'nodeDns', ['context', 'errors', 'golang.org/x/net/dns/dnsmessage', 'io', 'net', 'net/netip', 'os', 'strconv', 'strings', 'sync', 'sync/atomic', 'time'], ['nodeNet', 'netErrors', 'eventLoop', 'promise', 'nodeInvoke', 'dynamic'], dnsHelper);
|
|
558
1015
|
const use = () => r.helper('nodeDns');
|
|
559
1016
|
defineClass(r, 'dns.LookupAddress', '*TnLookupAddress', 'class', '', 'address=string; family=float64', '', '');
|
|
560
1017
|
defineClass(r, 'dns.MxRecord', '*TnMxRecord', 'class', '', 'exchange=string; priority=float64', '', '');
|
|
561
1018
|
defineClass(r, 'dns.SrvRecord', '*TnSrvRecord', 'class', '', 'name=string; port=float64; priority=float64; weight=float64', '', '');
|
|
1019
|
+
defineClass(r, 'dns.RecordWithTtl', '*TnRecordWithTtl', 'class', '', 'address=string; ttl=float64', '', '');
|
|
1020
|
+
defineClass(r, 'dns.SoaRecord', '*TnSoaRecord', 'class', '', 'nsname=string; hostmaster=string; serial=float64; refresh=float64; retry=float64; expire=float64; minttl=float64', '', '');
|
|
1021
|
+
defineClass(r, 'dns.NaptrRecord', '*TnNaptrRecord', 'class', '', 'flags=string; service=string; regexp=string; replacement=string; order=float64; preference=float64', '', '');
|
|
562
1022
|
r.functions['dns.lookup'] = (c) => {
|
|
563
1023
|
use();
|
|
564
1024
|
return `TnDnsLookup(${c.args.join(', ')})`;
|
|
@@ -583,12 +1043,12 @@ export function registerDns(r) {
|
|
|
583
1043
|
const resolver = (fn, typeFn) => {
|
|
584
1044
|
const callback = (recv) => (c) => {
|
|
585
1045
|
use();
|
|
586
|
-
const target =
|
|
1046
|
+
const target = typeFn(c.nodes);
|
|
587
1047
|
return `TnDnsResolveCb(${recv || c.recv}.${target}, ${c.args[0]}, ${c.args[c.args.length - 1]})`;
|
|
588
1048
|
};
|
|
589
1049
|
const promise = (recv) => (c) => {
|
|
590
1050
|
use();
|
|
591
|
-
const target =
|
|
1051
|
+
const target = typeFn(c.nodes);
|
|
592
1052
|
return `TnDnsResolvePromise(${recv || c.recv}.${target}, ${c.args[0]})`;
|
|
593
1053
|
};
|
|
594
1054
|
const cbTypes = (nodes) => ['*TnError', RESOLVERS[typeFn(nodes)]];
|
|
@@ -603,8 +1063,11 @@ export function registerDns(r) {
|
|
|
603
1063
|
r.methods[`dns/promises.Resolver#${fn}`] = promise('');
|
|
604
1064
|
r.typers[`dns/promises.Resolver#${fn}`] = promiseType;
|
|
605
1065
|
};
|
|
606
|
-
for (const fn of Object.keys(RESOLVERS))
|
|
607
|
-
|
|
1066
|
+
for (const fn of Object.keys(RESOLVERS)) {
|
|
1067
|
+
if (fn.endsWith('Ttl'))
|
|
1068
|
+
continue;
|
|
1069
|
+
resolver(fn, fn === 'resolve4' || fn === 'resolve6' ? (nodes) => withTtl(fn, nodes) : (_n) => fn);
|
|
1070
|
+
}
|
|
608
1071
|
resolver('resolve', rrtypeOf);
|
|
609
1072
|
defineClass(r, 'dns.LookupServiceResult', '*TnLookupService', 'class', '', 'hostname=string; service=string', '', '');
|
|
610
1073
|
r.functions['dns.lookupService'] = (c) => {
|