14358372723

Committed 09 Apr 2025 01:26PM UTC coverage: 56.696% (-12.3%) from 69.037%

Build # 14358372723

Build Type

Pull #9696

github

Committed by

web-flow

Commit Message

Merge e2837e400 into 867d27d68

Pull Request Pull Request #9696: Add `development_guidelines.md` for both human and machine

Run Details

107055 of 188823 relevant lines covered (56.7%)

22721.56 hits per line

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

60.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 {	×
36	customTypeOverrideMtx.Lock()	×
37	defer customTypeOverrideMtx.Unlock()	×
38		×
39	customTypeOverride = make(map[MessageType]struct{}, len(overrideTypes))	×
40		×
41	for _, t := range overrideTypes {	×
42	msgType := MessageType(t)	×
43		×
44	if msgType >= CustomTypeStart {	×
45	return fmt.Errorf("can't override type: %v, already "+	×
46	"in custom range", t)	×
47	}	×
48
49	customTypeOverride[msgType] = struct{}{}	×
50	}
51
52	return nil	×
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 {	813✔
58	customTypeOverrideMtx.RLock()	813✔
59	defer customTypeOverrideMtx.RUnlock()	813✔
60		813✔
61	_, ok := customTypeOverride[t]	813✔
62		813✔
63	return ok	813✔
64	}	813✔
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) {	11✔
82	if msgType < CustomTypeStart && !IsCustomOverride(msgType) {	11✔
83	return nil, fmt.Errorf("msg type: %d not in custom range: %v "+	×
84	"and not overridden", msgType, CustomTypeStart)	×
85	}	×
86
87	return &Custom{	11✔
88	Type: msgType,	11✔
89	Data: data,	11✔
90	}, nil	11✔
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 {	23✔
98	_, err := b.Write(c.Data)	23✔
99	return err	23✔
100	}	23✔
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 {	9✔
107	var b bytes.Buffer	9✔
108	if _, err := io.Copy(&b, r); err != nil {	9✔
109	return err	×
110	}	×
111
112	c.Data = b.Bytes()	9✔
113		9✔
114	return nil	9✔
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 {	14✔
122	return c.Type	14✔
123	}	14✔
124
125	// SerializedSize returns the serialized size of the message in bytes.
126	//
127	// This is part of the lnwire.SizeableMessage interface.
128	func (c *Custom) SerializedSize() (uint32, error) {	9✔
129	return MessageSerializedSize(c)	9✔
130	}	9✔

lightningnetwork / lnd / 14358372723

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