14975891860

Committed 12 May 2025 03:10PM UTC coverage: 58.559% (-10.5%) from 69.02%

Build # 14975891860

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9798 from ellemouton/graphFixNotificationSubs

graph/db: synchronous topology client subscriptions/cancellations

Run Details

6 of 8 new or added lines in 2 files covered. (75.0%)

28334 existing lines in 451 files now uncovered.

97366 of 166270 relevant lines covered (58.56%)

1.82 hits per line

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

71.36

/accessman.go

package lnd

import (
        "context"
        "fmt"
        "maps"
        "sync"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btclog/v2"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/lnutils"
)

// accessMan is responsible for managing the server's access permissions.
type accessMan struct {
        cfg *accessManConfig

        // banScoreMtx is used for the server's ban tracking. If the server
        // mutex is also going to be locked, ensure that this is locked after
        // the server mutex.
        banScoreMtx sync.RWMutex

        // peerCounts is a mapping from remote public key to {bool, uint64}
        // where the bool indicates that we have an open/closed channel with
        // the peer and where the uint64 indicates the number of pending-open
        // channels we currently have with them. This mapping will be used to
        // determine access permissions for the peer. The map key is the
        // string-version of the serialized public key.
        //
        // NOTE: This MUST be accessed with the banScoreMtx held.
        peerCounts map[string]channeldb.ChanCount

        // peerScores stores each connected peer's access status. The map key
        // is the string-version of the serialized public key.
        //
        // NOTE: This MUST be accessed with the banScoreMtx held.
        peerScores map[string]peerSlotStatus

        // numRestricted tracks the number of peers with restricted access in
        // peerScores. This MUST be accessed with the banScoreMtx held.
        numRestricted int64
}

type accessManConfig struct {
        // initAccessPerms checks the channeldb for initial access permissions
        // and then populates the peerCounts and peerScores maps.
        initAccessPerms func() (map[string]channeldb.ChanCount, error)

        // shouldDisconnect determines whether we should disconnect a peer or
        // not.
        shouldDisconnect func(*btcec.PublicKey) (bool, error)

        // maxRestrictedSlots is the number of restricted slots we'll allocate.
        maxRestrictedSlots int64
}

func newAccessMan(cfg *accessManConfig) (*accessMan, error) {
        a := &accessMan{
                cfg:        cfg,
                peerCounts: make(map[string]channeldb.ChanCount),
                peerScores: make(map[string]peerSlotStatus),
        }

        counts, err := a.cfg.initAccessPerms()
        if err != nil {
                return nil, err
        }

        // We'll populate the server's peerCounts map with the counts fetched
        // via initAccessPerms. Also note that we haven't yet connected to the
        // peers.
        maps.Copy(a.peerCounts, counts)

        acsmLog.Info("Access Manager initialized")

        return a, nil
}

// assignPeerPerms assigns a new peer its permissions. This does not track the
// access in the maps. This is intentional.
func (a *accessMan) assignPeerPerms(remotePub *btcec.PublicKey) (
        peerAccessStatus, error) {

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        peerMapKey := string(remotePub.SerializeCompressed())

        acsmLog.DebugS(ctx, "Assigning permissions")

        // Default is restricted unless the below filters say otherwise.
        access := peerStatusRestricted

        shouldDisconnect, err := a.cfg.shouldDisconnect(remotePub)
        if err != nil {
                acsmLog.ErrorS(ctx, "Error checking disconnect status", err)

                // Access is restricted here.
                return access, err
        }

        if shouldDisconnect {
                acsmLog.WarnS(ctx, "Peer is banned, assigning restricted access",
                        ErrGossiperBan)

                // Access is restricted here.
                return access, ErrGossiperBan
        }

        // Lock banScoreMtx for reading so that we can update the banning maps
        // below.
        a.banScoreMtx.RLock()
        defer a.banScoreMtx.RUnlock()

        if count, found := a.peerCounts[peerMapKey]; found {
                if count.HasOpenOrClosedChan {
                        acsmLog.DebugS(ctx, "Peer has open/closed channel, "+
                                "assigning protected access")

                        access = peerStatusProtected
                } else if count.PendingOpenCount != 0 {
                        acsmLog.DebugS(ctx, "Peer has pending channel(s), "+
                                "assigning temporary access")

                        access = peerStatusTemporary
                }
        }

        // If we've reached this point and access hasn't changed from
        // restricted, then we need to check if we even have a slot for this
        // peer.
        if access == peerStatusRestricted {
                acsmLog.DebugS(ctx, "Peer has no channels, assigning "+
                        "restricted access")

                if a.numRestricted >= a.cfg.maxRestrictedSlots {
                        acsmLog.WarnS(ctx, "No more restricted slots "+
                                "available, denying peer",
                                ErrNoMoreRestrictedAccessSlots,
                                "num_restricted", a.numRestricted,
                                "max_restricted", a.cfg.maxRestrictedSlots)

                        return access, ErrNoMoreRestrictedAccessSlots
                }
        }

        return access, nil
}

// newPendingOpenChan is called after the pending-open channel has been
// committed to the database. This may transition a restricted-access peer to a
// temporary-access peer.
func (a *accessMan) newPendingOpenChan(remotePub *btcec.PublicKey) error {
        a.banScoreMtx.Lock()
        defer a.banScoreMtx.Unlock()

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        acsmLog.DebugS(ctx, "Processing new pending open channel")

        peerMapKey := string(remotePub.SerializeCompressed())

        // Fetch the peer's access status from peerScores.
        status, found := a.peerScores[peerMapKey]
        if !found {
                acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)

                // If we didn't find the peer, we'll return an error.
                return ErrNoPeerScore
        }

        switch status.state {
        case peerStatusProtected:
                acsmLog.DebugS(ctx, "Peer already protected, no change")

                // If this peer's access status is protected, we don't need to
                // do anything.
                return nil

        case peerStatusTemporary:
                // If this peer's access status is temporary, we'll need to
                // update the peerCounts map. The peer's access status will stay
                // temporary.
                peerCount, found := a.peerCounts[peerMapKey]
                if !found {
                        // Error if we did not find any info in peerCounts.
                        acsmLog.ErrorS(ctx, "Pending peer info not found",
                                ErrNoPendingPeerInfo)

                        return ErrNoPendingPeerInfo
                }

                // Increment the pending channel amount.
                peerCount.PendingOpenCount += 1
                a.peerCounts[peerMapKey] = peerCount

                acsmLog.DebugS(ctx, "Peer is temporary, incremented "+
                        "pending count",
                        "pending_count", peerCount.PendingOpenCount)

        case peerStatusRestricted:
                // If the peer's access status is restricted, then we can
                // transition it to a temporary-access peer. We'll need to
                // update numRestricted and also peerScores. We'll also need to
                // update peerCounts.
                peerCount := channeldb.ChanCount{
                        HasOpenOrClosedChan: false,
                        PendingOpenCount:    1,
                }

                a.peerCounts[peerMapKey] = peerCount

                // A restricted-access slot has opened up.
                oldRestricted := a.numRestricted
                a.numRestricted -= 1

                a.peerScores[peerMapKey] = peerSlotStatus{
                        state: peerStatusTemporary,
                }

                acsmLog.InfoS(ctx, "Peer transitioned restricted -> "+
                        "temporary (pending open)",
                        "old_restricted", oldRestricted,
                        "new_restricted", a.numRestricted)

        default:
                // This should not be possible.
                err := fmt.Errorf("invalid peer access status %v for %x",
                        status.state, peerMapKey)
                acsmLog.ErrorS(ctx, "Invalid peer access status", err)

                return err
        }

        return nil
}

// newPendingCloseChan is called when a pending-open channel prematurely closes
// before the funding transaction has confirmed. This potentially demotes a
// temporary-access peer to a restricted-access peer. If no restricted-access
// slots are available, the peer will be disconnected.
func (a *accessMan) newPendingCloseChan(remotePub *btcec.PublicKey) error {
        a.banScoreMtx.Lock()
        defer a.banScoreMtx.Unlock()

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        acsmLog.DebugS(ctx, "Processing pending channel close")

        peerMapKey := string(remotePub.SerializeCompressed())

        // Fetch the peer's access status from peerScores.
        status, found := a.peerScores[peerMapKey]
        if !found {
                acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)

                return ErrNoPeerScore
        }

        switch status.state {
        case peerStatusProtected:
                // If this peer is protected, we don't do anything.
                acsmLog.DebugS(ctx, "Peer is protected, no change")

                return nil

        case peerStatusTemporary:
                // If this peer is temporary, we need to check if it will
                // revert to a restricted-access peer.
                peerCount, found := a.peerCounts[peerMapKey]
                if !found {
                        acsmLog.ErrorS(ctx, "Pending peer info not found",
                                ErrNoPendingPeerInfo)

                        // Error if we did not find any info in peerCounts.
                        return ErrNoPendingPeerInfo
                }

                currentNumPending := peerCount.PendingOpenCount - 1

                acsmLog.DebugS(ctx, "Peer is temporary, decrementing "+
                        "pending count",
                        "pending_count", currentNumPending)

                if currentNumPending == 0 {
                        // Remove the entry from peerCounts.
                        delete(a.peerCounts, peerMapKey)

                        // If this is the only pending-open channel for this
                        // peer and it's getting removed, attempt to demote
                        // this peer to a restricted peer.
                        if a.numRestricted == a.cfg.maxRestrictedSlots {
                                // There are no available restricted slots, so
                                // we need to disconnect this peer. We leave
                                // this up to the caller.
                                acsmLog.WarnS(ctx, "Peer last pending "+
                                        "channel closed: ",
                                        ErrNoMoreRestrictedAccessSlots,
                                        "num_restricted", a.numRestricted,
                                        "max_restricted", a.cfg.maxRestrictedSlots)

                                return ErrNoMoreRestrictedAccessSlots
                        }

                        // Otherwise, there is an available restricted-access
                        // slot, so we can demote this peer.
                        a.peerScores[peerMapKey] = peerSlotStatus{
                                state: peerStatusRestricted,
                        }

                        // Update numRestricted.
                        oldRestricted := a.numRestricted
                        a.numRestricted++

                        acsmLog.InfoS(ctx, "Peer transitioned "+
                                "temporary -> restricted "+
                                "(last pending closed)",
                                "old_restricted", oldRestricted,
                                "new_restricted", a.numRestricted)

                        return nil
                }

                // Else, we don't need to demote this peer since it has other
                // pending-open channels with us.
                peerCount.PendingOpenCount = currentNumPending
                a.peerCounts[peerMapKey] = peerCount

                acsmLog.DebugS(ctx, "Peer still has other pending channels",
                        "pending_count", currentNumPending)

                return nil

        case peerStatusRestricted:
                // This should not be possible. This indicates an error.
                err := fmt.Errorf("invalid peer access state transition: "+
                        "pending close for restricted peer %x", peerMapKey)
                acsmLog.ErrorS(ctx, "Invalid peer access state transition", err)

                return err

        default:
                // This should not be possible.
                err := fmt.Errorf("invalid peer access status %v for %x",
                        status.state, peerMapKey)
                acsmLog.ErrorS(ctx, "Invalid peer access status", err)

                return err
        }
}

// newOpenChan is called when a pending-open channel becomes an open channel
// (i.e. the funding transaction has confirmed). If the remote peer is a
// temporary-access peer, it will be promoted to a protected-access peer.
func (a *accessMan) newOpenChan(remotePub *btcec.PublicKey) error {
        a.banScoreMtx.Lock()
        defer a.banScoreMtx.Unlock()

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        acsmLog.DebugS(ctx, "Processing new open channel")

        peerMapKey := string(remotePub.SerializeCompressed())

        // Fetch the peer's access status from peerScores.
        status, found := a.peerScores[peerMapKey]
        if !found {
                // If we didn't find the peer, we'll return an error.
                acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)

                return ErrNoPeerScore
        }

        switch status.state {
        case peerStatusProtected:
                acsmLog.DebugS(ctx, "Peer already protected, no change")

                // If the peer's state is already protected, we don't need to do
                // anything more.
                return nil

        case peerStatusTemporary:
                // If the peer's state is temporary, we'll upgrade the peer to
                // a protected peer.
                peerCount, found := a.peerCounts[peerMapKey]
                if !found {
                        // Error if we did not find any info in peerCounts.
                        acsmLog.ErrorS(ctx, "Pending peer info not found",
                                ErrNoPendingPeerInfo)

                        return ErrNoPendingPeerInfo
                }

                peerCount.HasOpenOrClosedChan = true
                a.peerCounts[peerMapKey] = peerCount

                newStatus := peerSlotStatus{
                        state: peerStatusProtected,
                }
                a.peerScores[peerMapKey] = newStatus

                acsmLog.InfoS(ctx, "Peer transitioned temporary -> "+
                        "protected (channel opened)")

                return nil

        case peerStatusRestricted:
                // This should not be possible. For the server to receive a
                // state-transition event via NewOpenChan, the server must have
                // previously granted this peer "temporary" access. This
                // temporary access would not have been revoked or downgraded
                // without `CloseChannel` being called with the pending
                // argument set to true. This means that an open-channel state
                // transition would be impossible. Therefore, we can return an
                // error.
                err := fmt.Errorf("invalid peer access status: new open "+
                        "channel for restricted peer %x", peerMapKey)

                acsmLog.ErrorS(ctx, "Invalid peer access status", err)

                return err

        default:
                // This should not be possible.
                err := fmt.Errorf("invalid peer access status %v for %x",
                        status.state, peerMapKey)

                acsmLog.ErrorS(ctx, "Invalid peer access status", err)

                return err
        }
}

// checkIncomingConnBanScore checks whether, given the remote's public hex-
// encoded key, we should not accept this incoming connection or immediately
// disconnect. This does not assign to the server's peerScores maps. This is
// just an inbound filter that the brontide listeners use.
func (a *accessMan) checkIncomingConnBanScore(remotePub *btcec.PublicKey) (
        bool, error) {

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        peerMapKey := string(remotePub.SerializeCompressed())

        acsmLog.TraceS(ctx, "Checking incoming connection ban score")

        a.banScoreMtx.RLock()
        defer a.banScoreMtx.RUnlock()

        if _, found := a.peerCounts[peerMapKey]; !found {
                acsmLog.DebugS(ctx, "Peer not found in counts, "+
                        "checking restricted slots")

                // Check numRestricted to see if there is an available slot. In
                // the future, it's possible to add better heuristics.
                if a.numRestricted < a.cfg.maxRestrictedSlots {
                        // There is an available slot.
                        acsmLog.DebugS(ctx, "Restricted slot available, "+
                                "accepting",
                                "num_restricted", a.numRestricted,
                                "max_restricted", a.cfg.maxRestrictedSlots)

                        return true, nil
                }

                // If there are no slots left, then we reject this connection.
                acsmLog.WarnS(ctx, "No restricted slots available, "+
                        "rejecting",
                        ErrNoMoreRestrictedAccessSlots,
                        "num_restricted", a.numRestricted,
                        "max_restricted", a.cfg.maxRestrictedSlots)

                return false, ErrNoMoreRestrictedAccessSlots
        }

        // Else, the peer is either protected or temporary.
        acsmLog.DebugS(ctx, "Peer found (protected/temporary), accepting")

        return true, nil
}

// addPeerAccess tracks a peer's access in the maps. This should be called when
// the peer has fully connected.
func (a *accessMan) addPeerAccess(remotePub *btcec.PublicKey,
        access peerAccessStatus) {

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        acsmLog.DebugS(ctx, "Adding peer access", "access", access)

        // Add the remote public key to peerScores.
        a.banScoreMtx.Lock()
        defer a.banScoreMtx.Unlock()

        peerMapKey := string(remotePub.SerializeCompressed())

        a.peerScores[peerMapKey] = peerSlotStatus{state: access}

        // Increment numRestricted.
        if access == peerStatusRestricted {
                oldRestricted := a.numRestricted
                a.numRestricted++

                acsmLog.DebugS(ctx, "Incremented restricted slots",
                        "old_restricted", oldRestricted,
                        "new_restricted", a.numRestricted)
        }
}

// removePeerAccess removes the peer's access from the maps. This should be
// called when the peer has been disconnected.
func (a *accessMan) removePeerAccess(remotePub *btcec.PublicKey) {
        a.banScoreMtx.Lock()
        defer a.banScoreMtx.Unlock()

        ctx := btclog.WithCtx(
                context.TODO(), lnutils.LogPubKey("peer", remotePub),
        )

        acsmLog.DebugS(ctx, "Removing peer access")

        peerMapKey := string(remotePub.SerializeCompressed())

        status, found := a.peerScores[peerMapKey]
        if !found {
                acsmLog.InfoS(ctx, "Peer score not found during removal")
                return
        }

        if status.state == peerStatusRestricted {
                // If the status is restricted, then we decrement from
                // numRestrictedSlots.
                oldRestricted := a.numRestricted
                a.numRestricted--

                acsmLog.DebugS(ctx, "Decremented restricted slots",
                        "old_restricted", oldRestricted,
                        "new_restricted", a.numRestricted)
        }

        acsmLog.TraceS(ctx, "Deleting peer from peerScores")

        delete(a.peerScores, peerMapKey)
}

1	package lnd
2
3	import (
4	"context"
5	"fmt"
6	"maps"
7	"sync"
8
9	"github.com/btcsuite/btcd/btcec/v2"
10	"github.com/btcsuite/btclog/v2"
11	"github.com/lightningnetwork/lnd/channeldb"
12	"github.com/lightningnetwork/lnd/lnutils"
13	)
14
15	// accessMan is responsible for managing the server's access permissions.
16	type accessMan struct {
17	cfg *accessManConfig
18
19	// banScoreMtx is used for the server's ban tracking. If the server
20	// mutex is also going to be locked, ensure that this is locked after
21	// the server mutex.
22	banScoreMtx sync.RWMutex
23
24	// peerCounts is a mapping from remote public key to {bool, uint64}
25	// where the bool indicates that we have an open/closed channel with
26	// the peer and where the uint64 indicates the number of pending-open
27	// channels we currently have with them. This mapping will be used to
28	// determine access permissions for the peer. The map key is the
29	// string-version of the serialized public key.
30	//
31	// NOTE: This MUST be accessed with the banScoreMtx held.
32	peerCounts map[string]channeldb.ChanCount
33
34	// peerScores stores each connected peer's access status. The map key
35	// is the string-version of the serialized public key.
36	//
37	// NOTE: This MUST be accessed with the banScoreMtx held.
38	peerScores map[string]peerSlotStatus
39
40	// numRestricted tracks the number of peers with restricted access in
41	// peerScores. This MUST be accessed with the banScoreMtx held.
42	numRestricted int64
43	}
44
45	type accessManConfig struct {
46	// initAccessPerms checks the channeldb for initial access permissions
47	// and then populates the peerCounts and peerScores maps.
48	initAccessPerms func() (map[string]channeldb.ChanCount, error)
49
50	// shouldDisconnect determines whether we should disconnect a peer or
51	// not.
52	shouldDisconnect func(*btcec.PublicKey) (bool, error)
53
54	// maxRestrictedSlots is the number of restricted slots we'll allocate.
55	maxRestrictedSlots int64
56	}
57
58	func newAccessMan(cfg accessManConfig) (accessMan, error) {	3✔
59	a := &accessMan{	3✔
60	cfg: cfg,	3✔
61	peerCounts: make(map[string]channeldb.ChanCount),	3✔
62	peerScores: make(map[string]peerSlotStatus),	3✔
63	}	3✔
64		3✔
65	counts, err := a.cfg.initAccessPerms()	3✔
66	if err != nil {	3✔
67	return nil, err	×
68	}	×
69
70	// We'll populate the server's peerCounts map with the counts fetched
71	// via initAccessPerms. Also note that we haven't yet connected to the
72	// peers.
73	maps.Copy(a.peerCounts, counts)	3✔
74		3✔
75	acsmLog.Info("Access Manager initialized")	3✔
76		3✔
77	return a, nil	3✔
78	}
79
80	// assignPeerPerms assigns a new peer its permissions. This does not track the
81	// access in the maps. This is intentional.
82	func (a accessMan) assignPeerPerms(remotePub btcec.PublicKey) (
83	peerAccessStatus, error) {	3✔
84		3✔
85	ctx := btclog.WithCtx(	3✔
86	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
87	)	3✔
88		3✔
89	peerMapKey := string(remotePub.SerializeCompressed())	3✔
90		3✔
91	acsmLog.DebugS(ctx, "Assigning permissions")	3✔
92		3✔
93	// Default is restricted unless the below filters say otherwise.	3✔
94	access := peerStatusRestricted	3✔
95		3✔
96	shouldDisconnect, err := a.cfg.shouldDisconnect(remotePub)	3✔
97	if err != nil {	3✔
98	acsmLog.ErrorS(ctx, "Error checking disconnect status", err)	×
99		×
100	// Access is restricted here.	×
101	return access, err	×
102	}	×
103
104	if shouldDisconnect {	3✔
105	acsmLog.WarnS(ctx, "Peer is banned, assigning restricted access",	×
106	ErrGossiperBan)	×
107		×
108	// Access is restricted here.	×
109	return access, ErrGossiperBan	×
110	}	×
111
112	// Lock banScoreMtx for reading so that we can update the banning maps
113	// below.
114	a.banScoreMtx.RLock()	3✔
115	defer a.banScoreMtx.RUnlock()	3✔
116		3✔
117	if count, found := a.peerCounts[peerMapKey]; found {	6✔
118	if count.HasOpenOrClosedChan {	6✔
119	acsmLog.DebugS(ctx, "Peer has open/closed channel, "+	3✔
120	"assigning protected access")	3✔
121		3✔
122	access = peerStatusProtected	3✔
123	} else if count.PendingOpenCount != 0 {	9✔
124	acsmLog.DebugS(ctx, "Peer has pending channel(s), "+	3✔
125	"assigning temporary access")	3✔
126		3✔
127	access = peerStatusTemporary	3✔
128	}	3✔
129	}
130
131	// If we've reached this point and access hasn't changed from
132	// restricted, then we need to check if we even have a slot for this
133	// peer.
134	if access == peerStatusRestricted {	6✔
135	acsmLog.DebugS(ctx, "Peer has no channels, assigning "+	3✔
136	"restricted access")	3✔
137		3✔
138	if a.numRestricted >= a.cfg.maxRestrictedSlots {	3✔
139	acsmLog.WarnS(ctx, "No more restricted slots "+	×
140	"available, denying peer",	×
141	ErrNoMoreRestrictedAccessSlots,	×
142	"num_restricted", a.numRestricted,	×
143	"max_restricted", a.cfg.maxRestrictedSlots)	×
144		×
145	return access, ErrNoMoreRestrictedAccessSlots	×
146	}	×
147	}
148
149	return access, nil	3✔
150	}
151
152	// newPendingOpenChan is called after the pending-open channel has been
153	// committed to the database. This may transition a restricted-access peer to a
154	// temporary-access peer.
155	func (a accessMan) newPendingOpenChan(remotePub btcec.PublicKey) error {	3✔
156	a.banScoreMtx.Lock()	3✔
157	defer a.banScoreMtx.Unlock()	3✔
158		3✔
159	ctx := btclog.WithCtx(	3✔
160	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
161	)	3✔
162		3✔
163	acsmLog.DebugS(ctx, "Processing new pending open channel")	3✔
164		3✔
165	peerMapKey := string(remotePub.SerializeCompressed())	3✔
166		3✔
167	// Fetch the peer's access status from peerScores.	3✔
168	status, found := a.peerScores[peerMapKey]	3✔
169	if !found {	3✔
170	acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)	×
171		×
172	// If we didn't find the peer, we'll return an error.	×
173	return ErrNoPeerScore	×
174	}	×
175
176	switch status.state {	3✔
177	case peerStatusProtected:	3✔
178	acsmLog.DebugS(ctx, "Peer already protected, no change")	3✔
179		3✔
180	// If this peer's access status is protected, we don't need to	3✔
181	// do anything.	3✔
182	return nil	3✔
183
184	case peerStatusTemporary:	3✔
185	// If this peer's access status is temporary, we'll need to	3✔
186	// update the peerCounts map. The peer's access status will stay	3✔
187	// temporary.	3✔
188	peerCount, found := a.peerCounts[peerMapKey]	3✔
189	if !found {	3✔
190	// Error if we did not find any info in peerCounts.	×
191	acsmLog.ErrorS(ctx, "Pending peer info not found",	×
192	ErrNoPendingPeerInfo)	×
193		×
194	return ErrNoPendingPeerInfo	×
195	}	×
196
197	// Increment the pending channel amount.
198	peerCount.PendingOpenCount += 1	3✔
199	a.peerCounts[peerMapKey] = peerCount	3✔
200		3✔
201	acsmLog.DebugS(ctx, "Peer is temporary, incremented "+	3✔
202	"pending count",	3✔
203	"pending_count", peerCount.PendingOpenCount)	3✔
204
205	case peerStatusRestricted:	3✔
206	// If the peer's access status is restricted, then we can	3✔
207	// transition it to a temporary-access peer. We'll need to	3✔
208	// update numRestricted and also peerScores. We'll also need to	3✔
209	// update peerCounts.	3✔
210	peerCount := channeldb.ChanCount{	3✔
211	HasOpenOrClosedChan: false,	3✔
212	PendingOpenCount: 1,	3✔
213	}	3✔
214		3✔
215	a.peerCounts[peerMapKey] = peerCount	3✔
216		3✔
217	// A restricted-access slot has opened up.	3✔
218	oldRestricted := a.numRestricted	3✔
219	a.numRestricted -= 1	3✔
220		3✔
221	a.peerScores[peerMapKey] = peerSlotStatus{	3✔
222	state: peerStatusTemporary,	3✔
223	}	3✔
224		3✔
225	acsmLog.InfoS(ctx, "Peer transitioned restricted -> "+	3✔
226	"temporary (pending open)",	3✔
227	"old_restricted", oldRestricted,	3✔
228	"new_restricted", a.numRestricted)	3✔
229
230	default:	×
231	// This should not be possible.	×
232	err := fmt.Errorf("invalid peer access status %v for %x",	×
233	status.state, peerMapKey)	×
234	acsmLog.ErrorS(ctx, "Invalid peer access status", err)	×
235		×
236	return err	×
237	}
238
239	return nil	3✔
240	}
241
242	// newPendingCloseChan is called when a pending-open channel prematurely closes
243	// before the funding transaction has confirmed. This potentially demotes a
244	// temporary-access peer to a restricted-access peer. If no restricted-access
245	// slots are available, the peer will be disconnected.
246	func (a accessMan) newPendingCloseChan(remotePub btcec.PublicKey) error {	3✔
247	a.banScoreMtx.Lock()	3✔
248	defer a.banScoreMtx.Unlock()	3✔
249		3✔
250	ctx := btclog.WithCtx(	3✔
251	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
252	)	3✔
253		3✔
254	acsmLog.DebugS(ctx, "Processing pending channel close")	3✔
255		3✔
256	peerMapKey := string(remotePub.SerializeCompressed())	3✔
257		3✔
258	// Fetch the peer's access status from peerScores.	3✔
259	status, found := a.peerScores[peerMapKey]	3✔
260	if !found {	3✔
261	acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)	×
262		×
263	return ErrNoPeerScore	×
264	}	×
265
266	switch status.state {	3✔
267	case peerStatusProtected:	×
268	// If this peer is protected, we don't do anything.	×
269	acsmLog.DebugS(ctx, "Peer is protected, no change")	×
270		×
271	return nil	×
272
273	case peerStatusTemporary:	3✔
274	// If this peer is temporary, we need to check if it will	3✔
275	// revert to a restricted-access peer.	3✔
276	peerCount, found := a.peerCounts[peerMapKey]	3✔
277	if !found {	3✔
278	acsmLog.ErrorS(ctx, "Pending peer info not found",	×
279	ErrNoPendingPeerInfo)	×
280		×
281	// Error if we did not find any info in peerCounts.	×
282	return ErrNoPendingPeerInfo	×
283	}	×
284
285	currentNumPending := peerCount.PendingOpenCount - 1	3✔
286		3✔
287	acsmLog.DebugS(ctx, "Peer is temporary, decrementing "+	3✔
288	"pending count",	3✔
289	"pending_count", currentNumPending)	3✔
290		3✔
291	if currentNumPending == 0 {	6✔
292	// Remove the entry from peerCounts.	3✔
293	delete(a.peerCounts, peerMapKey)	3✔
294		3✔
295	// If this is the only pending-open channel for this	3✔
296	// peer and it's getting removed, attempt to demote	3✔
297	// this peer to a restricted peer.	3✔
298	if a.numRestricted == a.cfg.maxRestrictedSlots {	3✔
UNCOV 299	// There are no available restricted slots, so	×
UNCOV 300	// we need to disconnect this peer. We leave	×
UNCOV 301	// this up to the caller.	×
UNCOV 302	acsmLog.WarnS(ctx, "Peer last pending "+	×
UNCOV 303	"channel closed: ",	×
UNCOV 304	ErrNoMoreRestrictedAccessSlots,	×
UNCOV 305	"num_restricted", a.numRestricted,	×
UNCOV 306	"max_restricted", a.cfg.maxRestrictedSlots)	×
UNCOV 307		×
UNCOV 308	return ErrNoMoreRestrictedAccessSlots	×
UNCOV 309	}	×
310
311	// Otherwise, there is an available restricted-access
312	// slot, so we can demote this peer.
313	a.peerScores[peerMapKey] = peerSlotStatus{	3✔
314	state: peerStatusRestricted,	3✔
315	}	3✔
316		3✔
317	// Update numRestricted.	3✔
318	oldRestricted := a.numRestricted	3✔
319	a.numRestricted++	3✔
320		3✔
321	acsmLog.InfoS(ctx, "Peer transitioned "+	3✔
322	"temporary -> restricted "+	3✔
323	"(last pending closed)",	3✔
324	"old_restricted", oldRestricted,	3✔
325	"new_restricted", a.numRestricted)	3✔
326		3✔
327	return nil	3✔
328	}
329
330	// Else, we don't need to demote this peer since it has other
331	// pending-open channels with us.
332	peerCount.PendingOpenCount = currentNumPending	×
333	a.peerCounts[peerMapKey] = peerCount	×
334		×
335	acsmLog.DebugS(ctx, "Peer still has other pending channels",	×
336	"pending_count", currentNumPending)	×
337		×
338	return nil	×
339
340	case peerStatusRestricted:	×
341	// This should not be possible. This indicates an error.	×
342	err := fmt.Errorf("invalid peer access state transition: "+	×
343	"pending close for restricted peer %x", peerMapKey)	×
344	acsmLog.ErrorS(ctx, "Invalid peer access state transition", err)	×
345		×
346	return err	×
347
348	default:	×
349	// This should not be possible.	×
350	err := fmt.Errorf("invalid peer access status %v for %x",	×
351	status.state, peerMapKey)	×
352	acsmLog.ErrorS(ctx, "Invalid peer access status", err)	×
353		×
354	return err	×
355	}
356	}
357
358	// newOpenChan is called when a pending-open channel becomes an open channel
359	// (i.e. the funding transaction has confirmed). If the remote peer is a
360	// temporary-access peer, it will be promoted to a protected-access peer.
361	func (a accessMan) newOpenChan(remotePub btcec.PublicKey) error {	3✔
362	a.banScoreMtx.Lock()	3✔
363	defer a.banScoreMtx.Unlock()	3✔
364		3✔
365	ctx := btclog.WithCtx(	3✔
366	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
367	)	3✔
368		3✔
369	acsmLog.DebugS(ctx, "Processing new open channel")	3✔
370		3✔
371	peerMapKey := string(remotePub.SerializeCompressed())	3✔
372		3✔
373	// Fetch the peer's access status from peerScores.	3✔
374	status, found := a.peerScores[peerMapKey]	3✔
375	if !found {	6✔
376	// If we didn't find the peer, we'll return an error.	3✔
377	acsmLog.ErrorS(ctx, "Peer score not found", ErrNoPeerScore)	3✔
378		3✔
379	return ErrNoPeerScore	3✔
380	}	3✔
381
382	switch status.state {	3✔
383	case peerStatusProtected:	3✔
384	acsmLog.DebugS(ctx, "Peer already protected, no change")	3✔
385		3✔
386	// If the peer's state is already protected, we don't need to do	3✔
387	// anything more.	3✔
388	return nil	3✔
389
390	case peerStatusTemporary:	3✔
391	// If the peer's state is temporary, we'll upgrade the peer to	3✔
392	// a protected peer.	3✔
393	peerCount, found := a.peerCounts[peerMapKey]	3✔
394	if !found {	3✔
395	// Error if we did not find any info in peerCounts.	×
396	acsmLog.ErrorS(ctx, "Pending peer info not found",	×
397	ErrNoPendingPeerInfo)	×
398		×
399	return ErrNoPendingPeerInfo	×
400	}	×
401
402	peerCount.HasOpenOrClosedChan = true	3✔
403	a.peerCounts[peerMapKey] = peerCount	3✔
404		3✔
405	newStatus := peerSlotStatus{	3✔
406	state: peerStatusProtected,	3✔
407	}	3✔
408	a.peerScores[peerMapKey] = newStatus	3✔
409		3✔
410	acsmLog.InfoS(ctx, "Peer transitioned temporary -> "+	3✔
411	"protected (channel opened)")	3✔
412		3✔
413	return nil	3✔
414
415	case peerStatusRestricted:	×
416	// This should not be possible. For the server to receive a	×
417	// state-transition event via NewOpenChan, the server must have	×
418	// previously granted this peer "temporary" access. This	×
419	// temporary access would not have been revoked or downgraded	×
420	// without `CloseChannel` being called with the pending	×
421	// argument set to true. This means that an open-channel state	×
422	// transition would be impossible. Therefore, we can return an	×
423	// error.	×
424	err := fmt.Errorf("invalid peer access status: new open "+	×
425	"channel for restricted peer %x", peerMapKey)	×
426		×
427	acsmLog.ErrorS(ctx, "Invalid peer access status", err)	×
428		×
429	return err	×
430
431	default:	×
432	// This should not be possible.	×
433	err := fmt.Errorf("invalid peer access status %v for %x",	×
434	status.state, peerMapKey)	×
435		×
436	acsmLog.ErrorS(ctx, "Invalid peer access status", err)	×
437		×
438	return err	×
439	}
440	}
441
442	// checkIncomingConnBanScore checks whether, given the remote's public hex-
443	// encoded key, we should not accept this incoming connection or immediately
444	// disconnect. This does not assign to the server's peerScores maps. This is
445	// just an inbound filter that the brontide listeners use.
446	func (a accessMan) checkIncomingConnBanScore(remotePub btcec.PublicKey) (
447	bool, error) {	3✔
448		3✔
449	ctx := btclog.WithCtx(	3✔
450	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
451	)	3✔
452		3✔
453	peerMapKey := string(remotePub.SerializeCompressed())	3✔
454		3✔
455	acsmLog.TraceS(ctx, "Checking incoming connection ban score")	3✔
456		3✔
457	a.banScoreMtx.RLock()	3✔
458	defer a.banScoreMtx.RUnlock()	3✔
459		3✔
460	if _, found := a.peerCounts[peerMapKey]; !found {	6✔
461	acsmLog.DebugS(ctx, "Peer not found in counts, "+	3✔
462	"checking restricted slots")	3✔
463		3✔
464	// Check numRestricted to see if there is an available slot. In	3✔
465	// the future, it's possible to add better heuristics.	3✔
466	if a.numRestricted < a.cfg.maxRestrictedSlots {	6✔
467	// There is an available slot.	3✔
468	acsmLog.DebugS(ctx, "Restricted slot available, "+	3✔
469	"accepting",	3✔
470	"num_restricted", a.numRestricted,	3✔
471	"max_restricted", a.cfg.maxRestrictedSlots)	3✔
472		3✔
473	return true, nil	3✔
474	}	3✔
475
476	// If there are no slots left, then we reject this connection.
477	acsmLog.WarnS(ctx, "No restricted slots available, "+	3✔
478	"rejecting",	3✔
479	ErrNoMoreRestrictedAccessSlots,	3✔
480	"num_restricted", a.numRestricted,	3✔
481	"max_restricted", a.cfg.maxRestrictedSlots)	3✔
482		3✔
483	return false, ErrNoMoreRestrictedAccessSlots	3✔
484	}
485
486	// Else, the peer is either protected or temporary.
487	acsmLog.DebugS(ctx, "Peer found (protected/temporary), accepting")	3✔
488		3✔
489	return true, nil	3✔
490	}
491
492	// addPeerAccess tracks a peer's access in the maps. This should be called when
493	// the peer has fully connected.
494	func (a accessMan) addPeerAccess(remotePub btcec.PublicKey,
495	access peerAccessStatus) {	3✔
496		3✔
497	ctx := btclog.WithCtx(	3✔
498	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
499	)	3✔
500		3✔
501	acsmLog.DebugS(ctx, "Adding peer access", "access", access)	3✔
502		3✔
503	// Add the remote public key to peerScores.	3✔
504	a.banScoreMtx.Lock()	3✔
505	defer a.banScoreMtx.Unlock()	3✔
506		3✔
507	peerMapKey := string(remotePub.SerializeCompressed())	3✔
508		3✔
509	a.peerScores[peerMapKey] = peerSlotStatus{state: access}	3✔
510		3✔
511	// Increment numRestricted.	3✔
512	if access == peerStatusRestricted {	6✔
513	oldRestricted := a.numRestricted	3✔
514	a.numRestricted++	3✔
515		3✔
516	acsmLog.DebugS(ctx, "Incremented restricted slots",	3✔
517	"old_restricted", oldRestricted,	3✔
518	"new_restricted", a.numRestricted)	3✔
519	}	3✔
520	}
521
522	// removePeerAccess removes the peer's access from the maps. This should be
523	// called when the peer has been disconnected.
524	func (a accessMan) removePeerAccess(remotePub btcec.PublicKey) {	3✔
525	a.banScoreMtx.Lock()	3✔
526	defer a.banScoreMtx.Unlock()	3✔
527		3✔
528	ctx := btclog.WithCtx(	3✔
529	context.TODO(), lnutils.LogPubKey("peer", remotePub),	3✔
530	)	3✔
531		3✔
532	acsmLog.DebugS(ctx, "Removing peer access")	3✔
533		3✔
534	peerMapKey := string(remotePub.SerializeCompressed())	3✔
535		3✔
536	status, found := a.peerScores[peerMapKey]	3✔
537	if !found {	3✔
538	acsmLog.InfoS(ctx, "Peer score not found during removal")	×
539	return	×
540	}	×
541
542	if status.state == peerStatusRestricted {	6✔
543	// If the status is restricted, then we decrement from	3✔
544	// numRestrictedSlots.	3✔
545	oldRestricted := a.numRestricted	3✔
546	a.numRestricted--	3✔
547		3✔
548	acsmLog.DebugS(ctx, "Decremented restricted slots",	3✔
549	"old_restricted", oldRestricted,	3✔
550	"new_restricted", a.numRestricted)	3✔
551	}	3✔
552
553	acsmLog.TraceS(ctx, "Deleting peer from peerScores")	3✔
554		3✔
555	delete(a.peerScores, peerMapKey)	3✔
556	}

lightningnetwork / lnd / 14975891860

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