13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 hits per line

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

57.45

/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 FundingCreated implements the lnwire.Message
// interface.
var _ Message = (*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
}

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.
UNCOV 35	func SetCustomOverrides(overrideTypes []uint16) error {	×
UNCOV 36	customTypeOverrideMtx.Lock()	×
UNCOV 37	defer customTypeOverrideMtx.Unlock()	×
UNCOV 38		×
UNCOV 39	customTypeOverride = make(map[MessageType]struct{}, len(overrideTypes))	×
UNCOV 40		×
UNCOV 41	for _, t := range overrideTypes {	×
UNCOV 42	msgType := MessageType(t)	×
UNCOV 43		×
UNCOV 44	if msgType >= CustomTypeStart {	×
45	return fmt.Errorf("can't override type: %v, already "+	×
46	"in custom range", t)	×
47	}	×
48
UNCOV 49	customTypeOverride[msgType] = struct{}{}	×
50	}
51
UNCOV 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 {	1✔
58	customTypeOverrideMtx.RLock()	1✔
59	defer customTypeOverrideMtx.RUnlock()	1✔
60		1✔
61	_, ok := customTypeOverride[t]	1✔
62		1✔
63	return ok	1✔
64	}	1✔
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 FundingCreated implements the lnwire.Message
73	// interface.
74	var _ Message = (*Custom)(nil)
75
76	// NewCustom instantiates a new custom message.
77	func NewCustom(msgType MessageType, data []byte) (*Custom, error) {	2✔
78	if msgType < CustomTypeStart && !IsCustomOverride(msgType) {	2✔
UNCOV 79	return nil, fmt.Errorf("msg type: %d not in custom range: %v "+	×
UNCOV 80	"and not overridden", msgType, CustomTypeStart)	×
UNCOV 81	}	×
82
83	return &Custom{	2✔
84	Type: msgType,	2✔
85	Data: data,	2✔
86	}, nil	2✔
87	}
88
89	// Encode serializes the target Custom message into the passed io.Writer
90	// implementation.
91	//
92	// This is part of the lnwire.Message interface.
93	func (c Custom) Encode(b bytes.Buffer, pver uint32) error {	5✔
94	_, err := b.Write(c.Data)	5✔
95	return err	5✔
96	}	5✔
97
98	// Decode deserializes the serialized Custom message stored in the passed
99	// io.Reader into the target Custom message.
100	//
101	// This is part of the lnwire.Message interface.
102	func (c *Custom) Decode(r io.Reader, pver uint32) error {	9✔
103	var b bytes.Buffer	9✔
104	if _, err := io.Copy(&b, r); err != nil {	9✔
105	return err	×
106	}	×
107
108	c.Data = b.Bytes()	9✔
109		9✔
110	return nil	9✔
111	}
112
113	// MsgType returns the uint32 code which uniquely identifies this message as a
114	// Custom message on the wire.
115	//
116	// This is part of the lnwire.Message interface.
117	func (c *Custom) MsgType() MessageType {	5✔
118	return c.Type	5✔
119	}	5✔

lightningnetwork / lnd / 13236757158

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