mirror of
https://github.com/sot-tech/mochi.git
synced 2026-04-26 23:50:00 -07:00
139 lines
3.7 KiB
Go
139 lines
3.7 KiB
Go
// Package bittorrent implements all of the abstractions used to decouple the
|
|
// protocol of a BitTorrent tracker from the logic of handling Announces and
|
|
// Scrapes.
|
|
package bittorrent
|
|
|
|
import (
|
|
"crypto/sha1"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"net/netip"
|
|
|
|
"github.com/rs/zerolog"
|
|
"github.com/sot-tech/mochi/pkg/str2bytes"
|
|
)
|
|
|
|
// PeerIDLen is length of peer id field in bytes
|
|
const PeerIDLen = 20
|
|
|
|
// PeerID represents a peer ID.
|
|
type PeerID [PeerIDLen]byte
|
|
|
|
// ErrInvalidPeerIDSize holds error about invalid PeerID size
|
|
var ErrInvalidPeerIDSize = fmt.Errorf("peer ID must be %d bytes", PeerIDLen)
|
|
|
|
var zeroPeerID PeerID
|
|
|
|
// NewPeerID creates a PeerID from a byte slice.
|
|
//
|
|
// It panics if b is not 20 bytes long.
|
|
func NewPeerID(b []byte) (PeerID, error) {
|
|
if len(b) != PeerIDLen {
|
|
return zeroPeerID, ErrInvalidPeerIDSize
|
|
}
|
|
return PeerID(b), nil
|
|
}
|
|
|
|
// Bytes returns slice of bytes represents this PeerID
|
|
func (p PeerID) Bytes() []byte {
|
|
return p[:]
|
|
}
|
|
|
|
// String implements fmt.Stringer, returning the base16 encoded PeerID.
|
|
func (p PeerID) String() string {
|
|
return hex.EncodeToString(p.Bytes())
|
|
}
|
|
|
|
// RawString returns a 20-byte string of the raw bytes of the ID.
|
|
func (p PeerID) RawString() string {
|
|
return str2bytes.BytesToString(p.Bytes())
|
|
}
|
|
|
|
// InfoHash represents an infohash.
|
|
type InfoHash string
|
|
|
|
const (
|
|
// InfoHashV1Len is the same as sha1.Size
|
|
InfoHashV1Len = sha1.Size
|
|
// InfoHashV2Len ... sha256.Size
|
|
InfoHashV2Len = sha256.Size
|
|
)
|
|
|
|
// ErrInvalidHashSize holds error about invalid InfoHash size
|
|
var ErrInvalidHashSize = fmt.Errorf("info hash must be either %d (for torrent V1) or %d (V2) bytes or same sizes x2 (if HEX encoded)", InfoHashV1Len, InfoHashV2Len)
|
|
|
|
// NewInfoHash creates an InfoHash from raw/hex byte slice.
|
|
func NewInfoHash(data []byte) (InfoHash, error) {
|
|
var ih InfoHash
|
|
switch l := len(data); l {
|
|
case InfoHashV1Len, InfoHashV2Len:
|
|
ih = InfoHash(data)
|
|
case InfoHashV1Len * 2, InfoHashV2Len * 2:
|
|
bb := make([]byte, l/2)
|
|
if _, err := hex.Decode(bb, data); err != nil {
|
|
return "", err
|
|
}
|
|
ih = InfoHash(str2bytes.BytesToString(bb))
|
|
default:
|
|
return "", ErrInvalidHashSize
|
|
}
|
|
return ih, nil
|
|
}
|
|
|
|
// NewInfoHashString creates an InfoHash from raw/hex string.
|
|
func NewInfoHashString(data string) (InfoHash, error) {
|
|
return NewInfoHash(str2bytes.StringToBytes(data))
|
|
}
|
|
|
|
// TruncateV1 returns truncated to 20-bytes length array of the corresponding InfoHash.
|
|
// If InfoHash is V2 (32 bytes), it will be truncated to 20 bytes
|
|
// according to BEP52.
|
|
func (i InfoHash) TruncateV1() InfoHash {
|
|
if len(i) == InfoHashV2Len {
|
|
return i[:InfoHashV1Len]
|
|
}
|
|
return i
|
|
}
|
|
|
|
// Bytes returns slice of bytes represents this InfoHash
|
|
func (i InfoHash) Bytes() []byte {
|
|
return str2bytes.StringToBytes(string(i))
|
|
}
|
|
|
|
// String implements fmt.Stringer, returning the base16 encoded InfoHash.
|
|
func (i InfoHash) String() string {
|
|
return hex.EncodeToString(i.Bytes())
|
|
}
|
|
|
|
// RawString returns a string of the raw bytes of the InfoHash.
|
|
func (i InfoHash) RawString() string {
|
|
return string(i)
|
|
}
|
|
|
|
// Peer represents the connection details of a peer that is returned in an
|
|
// announce response.
|
|
type Peer struct {
|
|
ID PeerID
|
|
netip.AddrPort
|
|
}
|
|
|
|
// Addr returns unmapped peer's IP address
|
|
func (p Peer) Addr() netip.Addr {
|
|
return p.AddrPort.Addr().Unmap()
|
|
}
|
|
|
|
// MarshalZerologObject writes fields into zerolog event
|
|
func (p Peer) MarshalZerologObject(e *zerolog.Event) {
|
|
e.Stringer("id", p.ID).
|
|
Stringer("address", p.Addr()).
|
|
Uint16("port", p.Port())
|
|
}
|
|
|
|
// ClientError represents an error that should be exposed to the client over
|
|
// the BitTorrent protocol implementation.
|
|
type ClientError string
|
|
|
|
// Error implements the error interface for ClientError.
|
|
func (c ClientError) Error() string { return string(c) }
|