15117244231

Committed 19 May 2025 03:37PM UTC coverage: 57.988% (-11.0%) from 68.99%

Build # 15117244231

Build Type

Pull #9825

github

Committed by

web-flow

Commit Message

Merge e714b31b8 into 3707b1fb7

Pull Request Pull Request #9825: Refactor Payment PR 1

Run Details

326 of 469 new or added lines in 4 files covered. (69.51%)

29180 existing lines in 455 files now uncovered.

96428 of 166290 relevant lines covered (57.99%)

1.22 hits per line

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

84.0

/lnwire/custom.go

package lnwire

import (
        "bytes"
        "fmt"
        "io"
        "sync"
)

// CustomTypeStart is the start of the custom type range for peer messages as
// defined in BOLT 01.
const CustomTypeStart MessageType = 32768

var (
        // customTypeOverride contains a set of message types < CustomTypeStart
        // that lnd allows to be treated as custom messages. This allows us to
        // override messages reserved for the protocol level and treat them as
        // custom messages. This set of message types is stored as a global so
        // that we do not need to pass around state when accounting for this
        // set of messages in message creation.
        //
        // Note: This global is protected by the customTypeOverride mutex.
        customTypeOverride map[MessageType]struct{}

        // customTypeOverrideMtx manages concurrent access to
        // customTypeOverride.
        customTypeOverrideMtx sync.RWMutex
)

// SetCustomOverrides validates that the set of override types are outside of
// the custom message range (there's no reason to override messages that are
// already within the range), and updates the customTypeOverride global to hold
// this set of message types. Note that this function will completely overwrite
// the set of overrides, so should be called with the full set of types.
func SetCustomOverrides(overrideTypes []uint16) error {
        customTypeOverrideMtx.Lock()
        defer customTypeOverrideMtx.Unlock()

        customTypeOverride = make(map[MessageType]struct{}, len(overrideTypes))

        for _, t := range overrideTypes {
                msgType := MessageType(t)

                if msgType >= CustomTypeStart {
                        return fmt.Errorf("can't override type: %v, already "+
                                "in custom range", t)
                }

                customTypeOverride[msgType] = struct{}{}
        }

        return nil
}

// IsCustomOverride returns a bool indicating whether the message type is one
// of the protocol messages that we override for custom use.
func IsCustomOverride(t MessageType) bool {
        customTypeOverrideMtx.RLock()
        defer customTypeOverrideMtx.RUnlock()

        _, ok := customTypeOverride[t]

        return ok
}

// Custom represents an application-defined wire message.
type Custom struct {
        Type MessageType
        Data []byte
}

// A compile time check to ensure Custom implements the lnwire.Message
// interface.
var _ Message = (*Custom)(nil)

// A compile time check to ensure Custom implements the lnwire.SizeableMessage
// interface.
var _ SizeableMessage = (*Custom)(nil)

// NewCustom instantiates a new custom message.
func NewCustom(msgType MessageType, data []byte) (*Custom, error) {
        if msgType < CustomTypeStart && !IsCustomOverride(msgType) {
                return nil, fmt.Errorf("msg type: %d not in custom range: %v "+
                        "and not overridden", msgType, CustomTypeStart)
        }

        return &Custom{
                Type: msgType,
                Data: data,
        }, nil
}

// Encode serializes the target Custom message into the passed io.Writer
// implementation.
//
// This is part of the lnwire.Message interface.
func (c *Custom) Encode(b *bytes.Buffer, pver uint32) error {
        _, err := b.Write(c.Data)
        return err
}

// Decode deserializes the serialized Custom message stored in the passed
// io.Reader into the target Custom message.
//
// This is part of the lnwire.Message interface.
func (c *Custom) Decode(r io.Reader, pver uint32) error {
        var b bytes.Buffer
        if _, err := io.Copy(&b, r); err != nil {
                return err
        }

        c.Data = b.Bytes()

        return nil
}

// MsgType returns the uint32 code which uniquely identifies this message as a
// Custom message on the wire.
//
// This is part of the lnwire.Message interface.
func (c *Custom) MsgType() MessageType {
        return c.Type
}

// SerializedSize returns the serialized size of the message in bytes.
//
// This is part of the lnwire.SizeableMessage interface.
func (c *Custom) SerializedSize() (uint32, error) {
        return MessageSerializedSize(c)
}

1	package lnwire
2
3	import (
4	"bytes"
5	"fmt"
6	"io"
7	"sync"
8	)
9
10	// CustomTypeStart is the start of the custom type range for peer messages as
11	// defined in BOLT 01.
12	const CustomTypeStart MessageType = 32768
13
14	var (
15	// customTypeOverride contains a set of message types < CustomTypeStart
16	// that lnd allows to be treated as custom messages. This allows us to
17	// override messages reserved for the protocol level and treat them as
18	// custom messages. This set of message types is stored as a global so
19	// that we do not need to pass around state when accounting for this
20	// set of messages in message creation.
21	//
22	// Note: This global is protected by the customTypeOverride mutex.
23	customTypeOverride map[MessageType]struct{}
24
25	// customTypeOverrideMtx manages concurrent access to
26	// customTypeOverride.
27	customTypeOverrideMtx sync.RWMutex
28	)
29
30	// SetCustomOverrides validates that the set of override types are outside of
31	// the custom message range (there's no reason to override messages that are
32	// already within the range), and updates the customTypeOverride global to hold
33	// this set of message types. Note that this function will completely overwrite
34	// the set of overrides, so should be called with the full set of types.
35	func SetCustomOverrides(overrideTypes []uint16) error {	2✔
36	customTypeOverrideMtx.Lock()	2✔
37	defer customTypeOverrideMtx.Unlock()	2✔
38		2✔
39	customTypeOverride = make(map[MessageType]struct{}, len(overrideTypes))	2✔
40		2✔
41	for _, t := range overrideTypes {	4✔
42	msgType := MessageType(t)	2✔
43		2✔
44	if msgType >= CustomTypeStart {	2✔
45	return fmt.Errorf("can't override type: %v, already "+	×
46	"in custom range", t)	×
47	}	×
48
49	customTypeOverride[msgType] = struct{}{}	2✔
50	}
51
52	return nil	2✔
53	}
54
55	// IsCustomOverride returns a bool indicating whether the message type is one
56	// of the protocol messages that we override for custom use.
57	func IsCustomOverride(t MessageType) bool {	2✔
58	customTypeOverrideMtx.RLock()	2✔
59	defer customTypeOverrideMtx.RUnlock()	2✔
60		2✔
61	_, ok := customTypeOverride[t]	2✔
62		2✔
63	return ok	2✔
64	}	2✔
65
66	// Custom represents an application-defined wire message.
67	type Custom struct {
68	Type MessageType
69	Data []byte
70	}
71
72	// A compile time check to ensure Custom implements the lnwire.Message
73	// interface.
74	var _ Message = (*Custom)(nil)
75
76	// A compile time check to ensure Custom implements the lnwire.SizeableMessage
77	// interface.
78	var _ SizeableMessage = (*Custom)(nil)
79
80	// NewCustom instantiates a new custom message.
81	func NewCustom(msgType MessageType, data []byte) (*Custom, error) {	2✔
82	if msgType < CustomTypeStart && !IsCustomOverride(msgType) {	4✔
83	return nil, fmt.Errorf("msg type: %d not in custom range: %v "+	2✔
84	"and not overridden", msgType, CustomTypeStart)	2✔
85	}	2✔
86
87	return &Custom{	2✔
88	Type: msgType,	2✔
89	Data: data,	2✔
90	}, nil	2✔
91	}
92
93	// Encode serializes the target Custom message into the passed io.Writer
94	// implementation.
95	//
96	// This is part of the lnwire.Message interface.
97	func (c Custom) Encode(b bytes.Buffer, pver uint32) error {	2✔
98	_, err := b.Write(c.Data)	2✔
99	return err	2✔
100	}	2✔
101
102	// Decode deserializes the serialized Custom message stored in the passed
103	// io.Reader into the target Custom message.
104	//
105	// This is part of the lnwire.Message interface.
106	func (c *Custom) Decode(r io.Reader, pver uint32) error {	2✔
107	var b bytes.Buffer	2✔
108	if _, err := io.Copy(&b, r); err != nil {	2✔
109	return err	×
110	}	×
111
112	c.Data = b.Bytes()	2✔
113		2✔
114	return nil	2✔
115	}
116
117	// MsgType returns the uint32 code which uniquely identifies this message as a
118	// Custom message on the wire.
119	//
120	// This is part of the lnwire.Message interface.
121	func (c *Custom) MsgType() MessageType {	2✔
122	return c.Type	2✔
123	}	2✔
124
125	// SerializedSize returns the serialized size of the message in bytes.
126	//
127	// This is part of the lnwire.SizeableMessage interface.
UNCOV 128	func (c *Custom) SerializedSize() (uint32, error) {	×
UNCOV 129	return MessageSerializedSize(c)	×
UNCOV 130	}	×

lightningnetwork / lnd / 15117244231

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