mirror of
https://github.com/GopeedLab/gopeed.git
synced 2026-11-18 06:13:42 +00:00
refactoring package
This commit is contained in:
1 parent
b7347459eb
commit
137ed5d229
20 files changed
+528
-166
No files matched your search
@@ -0,0 +1,51 @@
|
||||
package peer
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
)
|
||||
|
||||
const (
|
||||
ProtocolIdentifier = "BitTorrent protocol"
|
||||
ProtocolIdentifierLength = 0x13
|
||||
)
|
||||
|
||||
// Handshake of Peer wire protocol
|
||||
// Per https://wiki.theory.org/index.php/BitTorrentSpecification#Handshake
|
||||
type Handshake struct {
|
||||
Pstrlen byte
|
||||
Pstr [19]byte
|
||||
Reserved [8]byte
|
||||
InfoHash [20]byte
|
||||
PeerID [20]byte
|
||||
}
|
||||
|
||||
func NewHandshake(reserved [8]byte, infoHash [20]byte, peerID [20]byte) *Handshake {
|
||||
var arr [ProtocolIdentifierLength]byte
|
||||
copy(arr[:], ProtocolIdentifier)
|
||||
return &Handshake{
|
||||
Pstrlen: ProtocolIdentifierLength,
|
||||
Pstr: arr,
|
||||
Reserved: reserved,
|
||||
InfoHash: infoHash,
|
||||
PeerID: peerID,
|
||||
}
|
||||
}
|
||||
|
||||
func (handshake *Handshake) Encode() []byte {
|
||||
writer := new(bytes.Buffer)
|
||||
err := binary.Write(writer, binary.BigEndian, handshake)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return writer.Bytes()
|
||||
}
|
||||
|
||||
func (handshake *Handshake) Decode(buf []byte) error {
|
||||
reader := bytes.NewReader(buf)
|
||||
err := binary.Read(reader, binary.BigEndian, handshake)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package peer
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
)
|
||||
|
||||
type MessageType int
|
||||
|
||||
const (
|
||||
Keepalive MessageType = -1
|
||||
Choke MessageType = iota
|
||||
Unchoke
|
||||
Interested
|
||||
NotInterested
|
||||
Have
|
||||
Bitfield
|
||||
Request
|
||||
Piece
|
||||
Cancel
|
||||
)
|
||||
|
||||
// Message protocol
|
||||
// length prefix| message ID | payload
|
||||
// 4-byte | 1-byte | remaining bytes
|
||||
// 100 | 5 | 99-bytes
|
||||
// https://wiki.theory.org/index.php/BitTorrentSpecification#Messages
|
||||
type Message struct {
|
||||
Length uint32
|
||||
Type int
|
||||
Payload []byte
|
||||
}
|
||||
|
||||
func SplitMessage(data []byte, atEOF bool) (advance int, token []byte, err error) {
|
||||
if !atEOF && len(data) > 4 {
|
||||
length := int(binary.BigEndian.Uint32(data))
|
||||
if len(data)-4 >= length {
|
||||
return length + 4, data[:length+4], nil
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (msg *Message) Encode() []byte {
|
||||
if msg.Type == -1 {
|
||||
return make([]byte, 4)
|
||||
} else {
|
||||
buf := make([]byte, 5+len(msg.Payload))
|
||||
binary.BigEndian.PutUint32(buf, msg.Length)
|
||||
buf[4] = byte(msg.Type)
|
||||
buf = append(buf, msg.Payload[:]...)
|
||||
return buf
|
||||
}
|
||||
}
|
||||
|
||||
func (msg *Message) Decode(buf []byte) {
|
||||
msg.Length = binary.BigEndian.Uint32(buf)
|
||||
if msg.Length == 0 {
|
||||
msg.Type = -1
|
||||
} else {
|
||||
msg.Type = int(buf[4])
|
||||
if msg.Length > 4 {
|
||||
msg.Payload = buf[5:]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type MsgBitfield []byte
|
||||
|
||||
// 某个分片是否下载完成
|
||||
func (mb MsgBitfield) get(i int) bool {
|
||||
bts := []byte(mb)
|
||||
index := i / 8
|
||||
if index >= len(bts) {
|
||||
return false
|
||||
}
|
||||
return bts[index]&(1<<uint(7-i%8)) > 0
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
package peer
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestMsgBitfield_get(t *testing.T) {
|
||||
type args struct {
|
||||
i int
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
mb MsgBitfield
|
||||
args args
|
||||
want bool
|
||||
}{
|
||||
{
|
||||
"case-0",
|
||||
MsgBitfield([]byte{convertByte("10000000")}),
|
||||
args{
|
||||
0,
|
||||
},
|
||||
true,
|
||||
},
|
||||
{
|
||||
"case-1",
|
||||
MsgBitfield([]byte{convertByte("01000000")}),
|
||||
args{
|
||||
1,
|
||||
},
|
||||
true,
|
||||
},
|
||||
{
|
||||
"case-2",
|
||||
MsgBitfield([]byte{convertByte("00000000")}),
|
||||
args{
|
||||
2,
|
||||
},
|
||||
false,
|
||||
},
|
||||
{
|
||||
"case-10",
|
||||
MsgBitfield([]byte{convertByte("00000000"), convertByte("00100000")}),
|
||||
args{
|
||||
10,
|
||||
},
|
||||
true,
|
||||
},
|
||||
{
|
||||
"case-11",
|
||||
MsgBitfield([]byte{convertByte("00000000"), convertByte("00100000")}),
|
||||
args{
|
||||
11,
|
||||
},
|
||||
false,
|
||||
},
|
||||
{
|
||||
"case-20",
|
||||
MsgBitfield([]byte{convertByte("00000000"), convertByte("00100000")}),
|
||||
args{
|
||||
20,
|
||||
},
|
||||
false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if got := tt.mb.get(tt.args.i); got != tt.want {
|
||||
t.Errorf("MsgBitfield.get() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func convertByte(bit string) byte {
|
||||
i, _ := strconv.ParseUint(bit, 2, 8)
|
||||
return byte(i)
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package peer
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/rand"
|
||||
"net"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type Peer struct {
|
||||
IP uint32
|
||||
Port uint16
|
||||
}
|
||||
|
||||
func (peer *Peer) Address() string {
|
||||
bts := make([]byte, 4)
|
||||
binary.BigEndian.PutUint32(bts, peer.IP)
|
||||
return net.IP(bts).String() + ":" + strconv.Itoa(int(peer.Port))
|
||||
}
|
||||
|
||||
// 生成Peer ID,规则为前三位固定字母(-GP)+SemVer(xyz)+End(-),后面随机生成
|
||||
// 参考:https://wiki.theory.org/index.php/BitTorrentSpecification#peer_id
|
||||
func GenPeerID() [20]byte {
|
||||
peerID := [20]byte{'-', 'G', 'P', '0', '0', '1', '-'}
|
||||
_, err := rand.Read(peerID[7:])
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return peerID
|
||||
}
|
||||
@@ -0,0 +1,316 @@
|
||||
package peer
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/cenkalti/mse"
|
||||
"gopeed/down/bt/metainfo"
|
||||
"io"
|
||||
"net"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type MessageType byte
|
||||
|
||||
const (
|
||||
ProtocolIdentifier = "BitTorrent protocol"
|
||||
ProtocolIdentifierLength = 0x13
|
||||
|
||||
Choke MessageType = iota
|
||||
Unchoke
|
||||
Interested
|
||||
NotInterested
|
||||
Have
|
||||
Bitfield
|
||||
Request
|
||||
Piece
|
||||
Cancel
|
||||
)
|
||||
|
||||
type Peer struct {
|
||||
IP uint32
|
||||
Port uint16
|
||||
|
||||
Torrent *Torrent
|
||||
conn net.Conn
|
||||
|
||||
// this client is choking the peer
|
||||
AmChoking bool
|
||||
// this client is interested in the peer
|
||||
AmInterested bool
|
||||
// peer is choking this client
|
||||
PeerChoking bool
|
||||
// peer is interested in this client
|
||||
PeerInterested bool
|
||||
}
|
||||
|
||||
func (peer *Peer) Address() string {
|
||||
bts := make([]byte, 4)
|
||||
binary.BigEndian.PutUint32(bts, peer.IP)
|
||||
return net.IP(bts).String() + ":" + strconv.Itoa(int(peer.Port))
|
||||
}
|
||||
|
||||
type Handshake struct {
|
||||
Pstrlen byte
|
||||
Pstr [19]byte
|
||||
Reserved [8]byte
|
||||
InfoHash [20]byte
|
||||
PeerID [20]byte
|
||||
}
|
||||
|
||||
type Message struct {
|
||||
Length uint32
|
||||
Type byte
|
||||
Payload []byte
|
||||
}
|
||||
|
||||
type MessageBitfield []bool
|
||||
|
||||
func decodeBitfield(payload []byte) MessageBitfield {
|
||||
bits := make([]bool, len(payload)*8)
|
||||
for i, b := range payload {
|
||||
for j := 0; j < 8; j++ {
|
||||
bits[i*8+j] = b&(1<<uint(7-j)) > 0
|
||||
}
|
||||
}
|
||||
return bits
|
||||
}
|
||||
|
||||
func newHandshake(reserved [8]byte, infoHash [20]byte, peerID [20]byte) *Handshake {
|
||||
var arr [ProtocolIdentifierLength]byte
|
||||
copy(arr[:], ProtocolIdentifier)
|
||||
return &Handshake{
|
||||
Pstrlen: ProtocolIdentifierLength,
|
||||
Pstr: arr,
|
||||
Reserved: reserved,
|
||||
InfoHash: infoHash,
|
||||
PeerID: peerID,
|
||||
}
|
||||
}
|
||||
|
||||
func (handshake *Handshake) encode() ([]byte, error) {
|
||||
writer := new(bytes.Buffer)
|
||||
err := binary.Write(writer, binary.BigEndian, handshake)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return writer.Bytes(), nil
|
||||
}
|
||||
|
||||
func (handshake *Handshake) decode(buf []byte) error {
|
||||
reader := bytes.NewReader(buf)
|
||||
err := binary.Read(reader, binary.BigEndian, handshake)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func dialMse(address string, infoHash [20]byte) (net.Conn, error) {
|
||||
conn, err := net.Dial("tcp", address)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
mseConn := mse.WrapConn(conn)
|
||||
_, err = mseConn.HandshakeOutgoing(infoHash[:], mse.PlainText, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return mseConn, nil
|
||||
}
|
||||
|
||||
func (peer *Peer) DoDownload() error {
|
||||
if peer.Port == 0 {
|
||||
return fmt.Errorf("error port %d", peer.Port)
|
||||
}
|
||||
conn, err := dialMse(peer.Address(), peer.Torrent.MetaInfo.InfoHash)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer conn.Close()
|
||||
err = peer.doHandshake(conn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// handshake success,init status
|
||||
peer.AmChoking = true
|
||||
peer.AmInterested = false
|
||||
peer.PeerChoking = true
|
||||
peer.PeerInterested = false
|
||||
|
||||
scanner := bufio.NewScanner(conn)
|
||||
scanner.Split(splitMessage)
|
||||
for scanner.Scan() {
|
||||
buf := scanner.Bytes()
|
||||
message := decodeMessage(buf)
|
||||
// keep-alive message
|
||||
if message.Length == 0 {
|
||||
|
||||
} else {
|
||||
switch MessageType(buf[4]) {
|
||||
case Choke:
|
||||
peer.PeerChoking = true
|
||||
break
|
||||
case Unchoke:
|
||||
peer.PeerChoking = false
|
||||
break
|
||||
case Interested:
|
||||
peer.PeerInterested = true
|
||||
break
|
||||
case NotInterested:
|
||||
peer.PeerInterested = false
|
||||
break
|
||||
case Have:
|
||||
break
|
||||
case Bitfield:
|
||||
bitfield := decodeBitfield(message.Payload)
|
||||
fmt.Println(bitfield)
|
||||
break
|
||||
case Request:
|
||||
break
|
||||
case Piece:
|
||||
break
|
||||
case Cancel:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*var (
|
||||
// This client is choking the peer
|
||||
amChocking = true
|
||||
// This client is interested in the peer
|
||||
amInterested = false
|
||||
// Peer is choking this client
|
||||
peerChocking = true
|
||||
// Peer is interested in this client
|
||||
peerInterested = false
|
||||
)
|
||||
|
||||
// Receive message
|
||||
var cacheBuf []byte
|
||||
buf := make([]byte, 8192)
|
||||
for {
|
||||
scanner := bufio.NewScanner(conn)
|
||||
n, err := conn.Read(buf)
|
||||
if n > 0 {
|
||||
if len(cacheBuf) > 0 {
|
||||
buf = append(cacheBuf, buf...)
|
||||
}
|
||||
msg, err := decodeMessage(buf, n)
|
||||
if err != nil {
|
||||
if err == NMD {
|
||||
cacheBuf = make([]byte, n)
|
||||
copy(cacheBuf, buf[0:n])
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
msgLength := binary.BigEndian.Uint32(buf)
|
||||
// keep-alive message
|
||||
if msgLength == 0 {
|
||||
|
||||
} else {
|
||||
switch MessageType(buf[4]) {
|
||||
case Choke:
|
||||
peerChocking = true
|
||||
break
|
||||
case Unchoke:
|
||||
peerChocking = false
|
||||
break
|
||||
case Interested:
|
||||
peerInterested = true
|
||||
break
|
||||
case NotInterested:
|
||||
peerInterested = false
|
||||
break
|
||||
case Have:
|
||||
break
|
||||
case Bitfield:
|
||||
break
|
||||
case Request:
|
||||
break
|
||||
case Piece:
|
||||
break
|
||||
case Cancel:
|
||||
break
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
if err != nil {
|
||||
if err == io.EOF {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
}*/
|
||||
return nil
|
||||
}
|
||||
|
||||
// Handshake of Peer wire protocol
|
||||
// Per https://wiki.theory.org/index.php/BitTorrentSpecification#Handshake
|
||||
func (peer *Peer) doHandshake(conn net.Conn) error {
|
||||
metaInfo := peer.Torrent.MetaInfo
|
||||
peerID := peer.Torrent.client.PeerID
|
||||
|
||||
reserved := [8]byte{}
|
||||
/* reserved[5] = 0x10
|
||||
reserved[6] = 0x0
|
||||
reserved[7] = 0x5*/
|
||||
handshakeReq := newHandshake(reserved, metaInfo.InfoHash, peerID)
|
||||
buf, err := handshakeReq.encode()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
conn.Write(buf)
|
||||
|
||||
var read [68]byte
|
||||
_, err = io.ReadFull(conn, read[:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
handshakeRes := new(Handshake)
|
||||
err = handshakeRes.decode(read[:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if handshakeRes.InfoHash != handshakeReq.InfoHash {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Message protocol
|
||||
// length prefix| message ID | payload
|
||||
// 4-byte | 1-byte | remaining bytes
|
||||
// 100 | 5 | 99-bytes
|
||||
// https://wiki.theory.org/index.php/BitTorrentSpecification#Messages
|
||||
func splitMessage(data []byte, atEOF bool) (advance int, token []byte, err error) {
|
||||
if !atEOF && len(data) > 4 {
|
||||
length := int(binary.BigEndian.Uint32(data))
|
||||
if len(data)-4 >= length {
|
||||
return length + 4, data[:length+4], nil
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func decodeMessage(buf []byte) *Message {
|
||||
msg := &Message{}
|
||||
msg.Length = binary.BigEndian.Uint32(buf)
|
||||
// keep-alive message
|
||||
if msg.Length > 0 {
|
||||
msg.Type = buf[4]
|
||||
msg.Payload = buf[5:]
|
||||
}
|
||||
return msg
|
||||
}
|
||||
|
||||
func doBitfield(peer *Peer, metaInfo *metainfo.MetaInfo, conn net.Conn) {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package peer
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func Test_decodeBitfield(t *testing.T) {
|
||||
fmt.Printf("%08b", 0xFF)
|
||||
type args struct {
|
||||
payload []byte
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
want MessageBitfield
|
||||
}{
|
||||
{
|
||||
"case-11111111",
|
||||
args{
|
||||
[]byte{0xFF},
|
||||
},
|
||||
[]bool{true, true, true, true, true, true, true, true},
|
||||
},
|
||||
{
|
||||
"case-10101010",
|
||||
args{
|
||||
[]byte{0xAA},
|
||||
},
|
||||
[]bool{true, false, true, false, true, false, true, false},
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if got := decodeBitfield(tt.args.payload); !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("decodeBitfield() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user