mirror of
https://source.quilibrium.com/quilibrium/ceremonyclient.git
synced 2024-11-11 02:35:18 +00:00
92 lines
2.6 KiB
Go
92 lines
2.6 KiB
Go
package libp2pquic
|
|
|
|
import (
|
|
"context"
|
|
|
|
ic "github.com/libp2p/go-libp2p/core/crypto"
|
|
"github.com/libp2p/go-libp2p/core/network"
|
|
"github.com/libp2p/go-libp2p/core/peer"
|
|
tpt "github.com/libp2p/go-libp2p/core/transport"
|
|
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
"github.com/quic-go/quic-go"
|
|
)
|
|
|
|
type conn struct {
|
|
quicConn quic.Connection
|
|
transport *transport
|
|
scope network.ConnManagementScope
|
|
|
|
localPeer peer.ID
|
|
localMultiaddr ma.Multiaddr
|
|
|
|
remotePeerID peer.ID
|
|
remotePubKey ic.PubKey
|
|
remoteMultiaddr ma.Multiaddr
|
|
}
|
|
|
|
var _ tpt.CapableConn = &conn{}
|
|
|
|
// Close closes the connection.
|
|
// It must be called even if the peer closed the connection in order for
|
|
// garbage collection to properly work in this package.
|
|
func (c *conn) Close() error {
|
|
return c.closeWithError(0, "")
|
|
}
|
|
|
|
func (c *conn) closeWithError(errCode quic.ApplicationErrorCode, errString string) error {
|
|
c.transport.removeConn(c.quicConn)
|
|
err := c.quicConn.CloseWithError(errCode, errString)
|
|
c.scope.Done()
|
|
return err
|
|
}
|
|
|
|
// IsClosed returns whether a connection is fully closed.
|
|
func (c *conn) IsClosed() bool {
|
|
return c.quicConn.Context().Err() != nil
|
|
}
|
|
|
|
func (c *conn) allowWindowIncrease(size uint64) bool {
|
|
return c.scope.ReserveMemory(int(size), network.ReservationPriorityMedium) == nil
|
|
}
|
|
|
|
// OpenStream creates a new stream.
|
|
func (c *conn) OpenStream(ctx context.Context) (network.MuxedStream, error) {
|
|
qstr, err := c.quicConn.OpenStreamSync(ctx)
|
|
return &stream{Stream: qstr}, err
|
|
}
|
|
|
|
// AcceptStream accepts a stream opened by the other side.
|
|
func (c *conn) AcceptStream() (network.MuxedStream, error) {
|
|
qstr, err := c.quicConn.AcceptStream(context.Background())
|
|
return &stream{Stream: qstr}, err
|
|
}
|
|
|
|
// LocalPeer returns our peer ID
|
|
func (c *conn) LocalPeer() peer.ID { return c.localPeer }
|
|
|
|
// RemotePeer returns the peer ID of the remote peer.
|
|
func (c *conn) RemotePeer() peer.ID { return c.remotePeerID }
|
|
|
|
// RemotePublicKey returns the public key of the remote peer.
|
|
func (c *conn) RemotePublicKey() ic.PubKey { return c.remotePubKey }
|
|
|
|
// LocalMultiaddr returns the local Multiaddr associated
|
|
func (c *conn) LocalMultiaddr() ma.Multiaddr { return c.localMultiaddr }
|
|
|
|
// RemoteMultiaddr returns the remote Multiaddr associated
|
|
func (c *conn) RemoteMultiaddr() ma.Multiaddr { return c.remoteMultiaddr }
|
|
|
|
func (c *conn) Transport() tpt.Transport { return c.transport }
|
|
|
|
func (c *conn) Scope() network.ConnScope { return c.scope }
|
|
|
|
// ConnState is the state of security connection.
|
|
func (c *conn) ConnState() network.ConnectionState {
|
|
t := "quic-v1"
|
|
if _, err := c.LocalMultiaddr().ValueForProtocol(ma.P_QUIC); err == nil {
|
|
t = "quic"
|
|
}
|
|
return network.ConnectionState{Transport: t}
|
|
}
|