16990665124

Committed 15 Aug 2025 01:10PM UTC coverage: 66.74% (-0.03%) from 66.765%

Build # 16990665124

Build Type

Pull #9455

github

Committed by

web-flow

Commit Message

Merge 035fac41d into fb1adfc21

Pull Request Pull Request #9455: [1/2] discovery+lnwire: add support for DNS host name in NodeAnnouncement msg

Run Details

116 of 188 new or added lines in 8 files covered. (61.7%)

110 existing lines in 23 files now uncovered.

136011 of 203791 relevant lines covered (66.74%)

21482.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.89

/graph/db/addr.go

package graphdb

import (
        "encoding/binary"
        "errors"
        "fmt"
        "io"
        "net"

        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/tor"
)

// addressType specifies the network protocol and version that should be used
// when connecting to a node at a particular address.
type addressType uint8

const (
        // tcp4Addr denotes an IPv4 TCP address.
        tcp4Addr addressType = 0

        // tcp6Addr denotes an IPv6 TCP address.
        tcp6Addr addressType = 1

        // v2OnionAddr denotes a version 2 Tor onion service address.
        v2OnionAddr addressType = 2

        // v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
        v3OnionAddr addressType = 3

        // opaqueAddrs denotes an address (or a set of addresses) that LND was
        // not able to parse since LND is not yet aware of the address type.
        opaqueAddrs addressType = 4

        // dnsAddr denotes a DNS address type.
        dnsAddr addressType = 5
)

// encodeDNSAddr encodes a DNS address.
func encodeDNSAddr(w io.Writer, addr *lnwire.DNSAddress) error {
        if _, err := w.Write([]byte{byte(dnsAddr)}); err != nil {
                return err
        }

        // Write the length of the hostname.
        hostLen := len(addr.Hostname)
        if _, err := w.Write([]byte{byte(hostLen)}); err != nil {
                return err
        }

        if _, err := w.Write([]byte(addr.Hostname)); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], addr.Port)
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// encodeTCPAddr serializes a TCP address into its compact raw bytes
// representation.
func encodeTCPAddr(w io.Writer, addr *net.TCPAddr) error {
        var (
                addrType byte
                ip       []byte
        )

        if addr.IP.To4() != nil {
                addrType = byte(tcp4Addr)
                ip = addr.IP.To4()
        } else {
                addrType = byte(tcp6Addr)
                ip = addr.IP.To16()
        }

        if ip == nil {
                return fmt.Errorf("unable to encode IP %v", addr.IP)
        }

        if _, err := w.Write([]byte{addrType}); err != nil {
                return err
        }

        if _, err := w.Write(ip); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], uint16(addr.Port))
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// encodeOnionAddr serializes an onion address into its compact raw bytes
// representation.
func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {
        var suffixIndex int
        hostLen := len(addr.OnionService)
        switch hostLen {
        case tor.V2Len:
                if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {
                        return err
                }
                suffixIndex = tor.V2Len - tor.OnionSuffixLen
        case tor.V3Len:
                if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {
                        return err
                }
                suffixIndex = tor.V3Len - tor.OnionSuffixLen
        default:
                return errors.New("unknown onion service length")
        }

        suffix := addr.OnionService[suffixIndex:]
        if suffix != tor.OnionSuffix {
                return fmt.Errorf("invalid suffix \"%v\"", suffix)
        }

        host, err := tor.Base32Encoding.DecodeString(
                addr.OnionService[:suffixIndex],
        )
        if err != nil {
                return err
        }

        // Sanity check the decoded length.
        switch {
        case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:
                return fmt.Errorf("onion service %v decoded to invalid host %x",
                        addr.OnionService, host)

        case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:
                return fmt.Errorf("onion service %v decoded to invalid host %x",
                        addr.OnionService, host)
        }

        if _, err := w.Write(host); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], uint16(addr.Port))
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// encodeOpaqueAddrs serializes the lnwire.OpaqueAddrs type to a raw set of
// bytes that we will persist.
func encodeOpaqueAddrs(w io.Writer, addr *lnwire.OpaqueAddrs) error {
        // Write the type byte.
        if _, err := w.Write([]byte{byte(opaqueAddrs)}); err != nil {
                return err
        }

        // Write the length of the payload.
        var l [2]byte
        binary.BigEndian.PutUint16(l[:], uint16(len(addr.Payload)))
        if _, err := w.Write(l[:]); err != nil {
                return err
        }

        // Write the payload.
        _, err := w.Write(addr.Payload)

        return err
}

// DeserializeAddr reads the serialized raw representation of an address and
// deserializes it into the actual address. This allows us to avoid address
// resolution within the channeldb package.
func DeserializeAddr(r io.Reader) (net.Addr, error) {
        var addrType [1]byte
        if _, err := r.Read(addrType[:]); err != nil {
                return nil, err
        }

        var address net.Addr
        switch addressType(addrType[0]) {
        case tcp4Addr:
                var ip [4]byte
                if _, err := r.Read(ip[:]); err != nil {
                        return nil, err
                }

                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &net.TCPAddr{
                        IP:   net.IP(ip[:]),
                        Port: int(binary.BigEndian.Uint16(port[:])),
                }

        case tcp6Addr:
                var ip [16]byte
                if _, err := r.Read(ip[:]); err != nil {
                        return nil, err
                }

                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &net.TCPAddr{
                        IP:   net.IP(ip[:]),
                        Port: int(binary.BigEndian.Uint16(port[:])),
                }

        case v2OnionAddr:
                var h [tor.V2DecodedLen]byte
                if _, err := r.Read(h[:]); err != nil {
                        return nil, err
                }

                var p [2]byte
                if _, err := r.Read(p[:]); err != nil {
                        return nil, err
                }

                onionService := tor.Base32Encoding.EncodeToString(h[:])
                onionService += tor.OnionSuffix
                port := int(binary.BigEndian.Uint16(p[:]))

                address = &tor.OnionAddr{
                        OnionService: onionService,
                        Port:         port,
                }

        case v3OnionAddr:
                var h [tor.V3DecodedLen]byte
                if _, err := r.Read(h[:]); err != nil {
                        return nil, err
                }

                var p [2]byte
                if _, err := r.Read(p[:]); err != nil {
                        return nil, err
                }

                onionService := tor.Base32Encoding.EncodeToString(h[:])
                onionService += tor.OnionSuffix
                port := int(binary.BigEndian.Uint16(p[:]))

                address = &tor.OnionAddr{
                        OnionService: onionService,
                        Port:         port,
                }

        case dnsAddr:
                // Read the length of the hostname.
                var hostLen [1]byte
                if _, err := r.Read(hostLen[:]); err != nil {
                        return nil, err
                }

                // Read the hostname.
                hostname := make([]byte, hostLen[0])
                if _, err := r.Read(hostname); err != nil {
                        return nil, err
                }

                // Read the port.
                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &lnwire.DNSAddress{
                        Hostname: string(hostname),
                        Port:     binary.BigEndian.Uint16(port[:]),
                }

        case opaqueAddrs:
                // Read the length of the payload.
                var l [2]byte
                if _, err := r.Read(l[:]); err != nil {
                        return nil, err
                }

                // Read the payload.
                payload := make([]byte, binary.BigEndian.Uint16(l[:]))
                if _, err := r.Read(payload); err != nil {
                        return nil, err
                }

                address = &lnwire.OpaqueAddrs{
                        Payload: payload,
                }

        default:
                return nil, ErrUnknownAddressType
        }

        return address, nil
}

// SerializeAddr serializes an address into its raw bytes representation so that
// it can be deserialized without requiring address resolution.
func SerializeAddr(w io.Writer, address net.Addr) error {
        switch addr := address.(type) {
        case *net.TCPAddr:
                return encodeTCPAddr(w, addr)
        case *tor.OnionAddr:
                return encodeOnionAddr(w, addr)
        case *lnwire.OpaqueAddrs:
                return encodeOpaqueAddrs(w, addr)
        case *lnwire.DNSAddress:
                return encodeDNSAddr(w, addr)
        default:
                return ErrUnknownAddressType
        }
}

1	package graphdb
2
3	import (
4	"encoding/binary"
5	"errors"
6	"fmt"
7	"io"
8	"net"
9
10	"github.com/lightningnetwork/lnd/lnwire"
11	"github.com/lightningnetwork/lnd/tor"
12	)
13
14	// addressType specifies the network protocol and version that should be used
15	// when connecting to a node at a particular address.
16	type addressType uint8
17
18	const (
19	// tcp4Addr denotes an IPv4 TCP address.
20	tcp4Addr addressType = 0
21
22	// tcp6Addr denotes an IPv6 TCP address.
23	tcp6Addr addressType = 1
24
25	// v2OnionAddr denotes a version 2 Tor onion service address.
26	v2OnionAddr addressType = 2
27
28	// v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
29	v3OnionAddr addressType = 3
30
31	// opaqueAddrs denotes an address (or a set of addresses) that LND was
32	// not able to parse since LND is not yet aware of the address type.
33	opaqueAddrs addressType = 4
34
35	// dnsAddr denotes a DNS address type.
36	dnsAddr addressType = 5
37	)
38
39	// encodeDNSAddr encodes a DNS address.
40	func encodeDNSAddr(w io.Writer, addr *lnwire.DNSAddress) error {	2✔
41	if _, err := w.Write([]byte{byte(dnsAddr)}); err != nil {	2✔
NEW 42	return err	×
NEW 43	}	×
44
45	// Write the length of the hostname.
46	hostLen := len(addr.Hostname)	2✔
47	if _, err := w.Write([]byte{byte(hostLen)}); err != nil {	2✔
NEW 48	return err	×
NEW 49	}	×
50
51	if _, err := w.Write([]byte(addr.Hostname)); err != nil {	2✔
NEW 52	return err	×
NEW 53	}	×
54
55	var port [2]byte	2✔
56	byteOrder.PutUint16(port[:], addr.Port)	2✔
57	if _, err := w.Write(port[:]); err != nil {	2✔
NEW 58	return err	×
NEW 59	}	×
60
61	return nil	2✔
62	}
63
64	// encodeTCPAddr serializes a TCP address into its compact raw bytes
65	// representation.
66	func encodeTCPAddr(w io.Writer, addr *net.TCPAddr) error {	2,132✔
67	var (	2,132✔
68	addrType byte	2,132✔
69	ip []byte	2,132✔
70	)	2,132✔
71		2,132✔
72	if addr.IP.To4() != nil {	3,874✔
73	addrType = byte(tcp4Addr)	1,742✔
74	ip = addr.IP.To4()	1,742✔
75	} else {	2,135✔
76	addrType = byte(tcp6Addr)	393✔
77	ip = addr.IP.To16()	393✔
78	}	393✔
79
80	if ip == nil {	2,136✔
81	return fmt.Errorf("unable to encode IP %v", addr.IP)	4✔
82	}	4✔
83
84	if _, err := w.Write([]byte{addrType}); err != nil {	2,128✔
85	return err	×
86	}	×
87
88	if _, err := w.Write(ip); err != nil {	2,128✔
89	return err	×
90	}	×
91
92	var port [2]byte	2,128✔
93	byteOrder.PutUint16(port[:], uint16(addr.Port))	2,128✔
94	if _, err := w.Write(port[:]); err != nil {	2,128✔
95	return err	×
96	}	×
97
98	return nil	2,128✔
99	}
100
101	// encodeOnionAddr serializes an onion address into its compact raw bytes
102	// representation.
103	func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {	212✔
104	var suffixIndex int	212✔
105	hostLen := len(addr.OnionService)	212✔
106	switch hostLen {	212✔
107	case tor.V2Len:	106✔
108	if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {	106✔
109	return err	×
110	}	×
111	suffixIndex = tor.V2Len - tor.OnionSuffixLen	106✔
112	case tor.V3Len:	108✔
113	if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {	108✔
114	return err	×
115	}	×
116	suffixIndex = tor.V3Len - tor.OnionSuffixLen	108✔
117	default:	1✔
118	return errors.New("unknown onion service length")	1✔
119	}
120
121	suffix := addr.OnionService[suffixIndex:]	211✔
122	if suffix != tor.OnionSuffix {	212✔
123	return fmt.Errorf("invalid suffix \"%v\"", suffix)	1✔
124	}	1✔
125
126	host, err := tor.Base32Encoding.DecodeString(	210✔
127	addr.OnionService[:suffixIndex],	210✔
128	)	210✔
129	if err != nil {	211✔
130	return err	1✔
131	}	1✔
132
133	// Sanity check the decoded length.
134	switch {	209✔
135	case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:	×
136	return fmt.Errorf("onion service %v decoded to invalid host %x",	×
137	addr.OnionService, host)	×
138
139	case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:	×
140	return fmt.Errorf("onion service %v decoded to invalid host %x",	×
141	addr.OnionService, host)	×
142	}
143
144	if _, err := w.Write(host); err != nil {	209✔
145	return err	×
146	}	×
147
148	var port [2]byte	209✔
149	byteOrder.PutUint16(port[:], uint16(addr.Port))	209✔
150	if _, err := w.Write(port[:]); err != nil {	209✔
151	return err	×
152	}	×
153
154	return nil	209✔
155	}
156
157	// encodeOpaqueAddrs serializes the lnwire.OpaqueAddrs type to a raw set of
158	// bytes that we will persist.
159	func encodeOpaqueAddrs(w io.Writer, addr *lnwire.OpaqueAddrs) error {	3✔
160	// Write the type byte.	3✔
161	if _, err := w.Write([]byte{byte(opaqueAddrs)}); err != nil {	3✔
162	return err	×
163	}	×
164
165	// Write the length of the payload.
166	var l [2]byte	3✔
167	binary.BigEndian.PutUint16(l[:], uint16(len(addr.Payload)))	3✔
168	if _, err := w.Write(l[:]); err != nil {	3✔
169	return err	×
170	}	×
171
172	// Write the payload.
173	_, err := w.Write(addr.Payload)	3✔
174		3✔
175	return err	3✔
176	}
177
178	// DeserializeAddr reads the serialized raw representation of an address and
179	// deserializes it into the actual address. This allows us to avoid address
180	// resolution within the channeldb package.
181	func DeserializeAddr(r io.Reader) (net.Addr, error) {	11,315✔
182	var addrType [1]byte	11,315✔
183	if _, err := r.Read(addrType[:]); err != nil {	11,315✔
184	return nil, err	×
185	}	×
186
187	var address net.Addr	11,315✔
188	switch addressType(addrType[0]) {	11,315✔
189	case tcp4Addr:	4,530✔
190	var ip [4]byte	4,530✔
191	if _, err := r.Read(ip[:]); err != nil {	4,530✔
192	return nil, err	×
193	}	×
194
195	var port [2]byte	4,530✔
196	if _, err := r.Read(port[:]); err != nil {	4,530✔
197	return nil, err	×
198	}	×
199
200	address = &net.TCPAddr{	4,530✔
201	IP: net.IP(ip[:]),	4,530✔
202	Port: int(binary.BigEndian.Uint16(port[:])),	4,530✔
203	}	4,530✔
204
205	case tcp6Addr:	6,571✔
206	var ip [16]byte	6,571✔
207	if _, err := r.Read(ip[:]); err != nil {	6,571✔
208	return nil, err	×
209	}	×
210
211	var port [2]byte	6,571✔
212	if _, err := r.Read(port[:]); err != nil {	6,571✔
213	return nil, err	×
214	}	×
215
216	address = &net.TCPAddr{	6,571✔
217	IP: net.IP(ip[:]),	6,571✔
218	Port: int(binary.BigEndian.Uint16(port[:])),	6,571✔
219	}	6,571✔
220
221	case v2OnionAddr:	108✔
222	var h [tor.V2DecodedLen]byte	108✔
223	if _, err := r.Read(h[:]); err != nil {	108✔
224	return nil, err	×
225	}	×
226
227	var p [2]byte	108✔
228	if _, err := r.Read(p[:]); err != nil {	108✔
229	return nil, err	×
230	}	×
231
232	onionService := tor.Base32Encoding.EncodeToString(h[:])	108✔
233	onionService += tor.OnionSuffix	108✔
234	port := int(binary.BigEndian.Uint16(p[:]))	108✔
235		108✔
236	address = &tor.OnionAddr{	108✔
237	OnionService: onionService,	108✔
238	Port: port,	108✔
239	}	108✔
240
241	case v3OnionAddr:	108✔
242	var h [tor.V3DecodedLen]byte	108✔
243	if _, err := r.Read(h[:]); err != nil {	108✔
244	return nil, err	×
245	}	×
246
247	var p [2]byte	108✔
248	if _, err := r.Read(p[:]); err != nil {	108✔
249	return nil, err	×
250	}	×
251
252	onionService := tor.Base32Encoding.EncodeToString(h[:])	108✔
253	onionService += tor.OnionSuffix	108✔
254	port := int(binary.BigEndian.Uint16(p[:]))	108✔
255		108✔
256	address = &tor.OnionAddr{	108✔
257	OnionService: onionService,	108✔
258	Port: port,	108✔
259	}	108✔
260
261	case dnsAddr:	3✔
262	// Read the length of the hostname.	3✔
263	var hostLen [1]byte	3✔
264	if _, err := r.Read(hostLen[:]); err != nil {	3✔
NEW 265	return nil, err	×
NEW 266	}	×
267
268	// Read the hostname.
269	hostname := make([]byte, hostLen[0])	3✔
270	if _, err := r.Read(hostname); err != nil {	3✔
NEW 271	return nil, err	×
NEW 272	}	×
273
274	// Read the port.
275	var port [2]byte	3✔
276	if _, err := r.Read(port[:]); err != nil {	3✔
NEW 277	return nil, err	×
NEW 278	}	×
279
280	address = &lnwire.DNSAddress{	3✔
281	Hostname: string(hostname),	3✔
282	Port: binary.BigEndian.Uint16(port[:]),	3✔
283	}	3✔
284
285	case opaqueAddrs:	4✔
286	// Read the length of the payload.	4✔
287	var l [2]byte	4✔
288	if _, err := r.Read(l[:]); err != nil {	4✔
289	return nil, err	×
290	}	×
291
292	// Read the payload.
293	payload := make([]byte, binary.BigEndian.Uint16(l[:]))	4✔
294	if _, err := r.Read(payload); err != nil {	4✔
295	return nil, err	×
296	}	×
297
298	address = &lnwire.OpaqueAddrs{	4✔
299	Payload: payload,	4✔
300	}	4✔
301
302	default:	×
303	return nil, ErrUnknownAddressType	×
304	}
305
306	return address, nil	11,315✔
307	}
308
309	// SerializeAddr serializes an address into its raw bytes representation so that
310	// it can be deserialized without requiring address resolution.
311	func SerializeAddr(w io.Writer, address net.Addr) error {	2,347✔
312	switch addr := address.(type) {	2,347✔
313	case *net.TCPAddr:	2,132✔
314	return encodeTCPAddr(w, addr)	2,132✔
315	case *tor.OnionAddr:	212✔
316	return encodeOnionAddr(w, addr)	212✔
317	case *lnwire.OpaqueAddrs:	3✔
318	return encodeOpaqueAddrs(w, addr)	3✔
319	case *lnwire.DNSAddress:	2✔
320	return encodeDNSAddr(w, addr)	2✔
321	default:	1✔
322	return ErrUnknownAddressType	1✔
323	}
324	}

lightningnetwork / lnd / 16990665124

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous