d
  8:announce
    41:http://bttracker.debian.org:6969/announce
  7:comment
    35:"Debian CD from cdimage.debian.org"
  13:creation date
    i1573903810e
  4:info
    d
      6:length
        i351272960e
      4:name
        31:debian-10.2.0-amd64-netinst.iso
      12:piece length
        i262144e
      6:pieces
        26800:�����PS�^�� (binary blob of the hashes of each piece)
    e
e

import (
  "github.com/jackpal/bencode-go"
)

type bencodeInfo struct {
  Pieces      string `bencode:"pieces"`
  PieceLength int    `bencode:"piece length"`
  Length      int    `bencode:"length"`
  Name        string `bencode:"name"`
}

type bencodeTorrent struct {
  Announce string      `bencode:"announce"`
  Info     bencodeInfo `bencode:"info"`
}

// Open 토렌트 파일을 파싱합니다
func Open(r io.Reader) (*bencodeTorrent, error) {
  bto := bencodeTorrent{}
  err := bencode.Unmarshal(r, &bto)
  if err != nil {
    return nil, err
  }
  return &bto, nil
}

type TorrentFile struct {
  Announce    string
  InfoHash    [20]byte
  PieceHashes [][20]byte
  PieceLength int
  Length      int
  Name        string
}

func (bto bencodeTorrent) toTorrentFile() (TorrentFile, error) {
  // …
}

func (t *TorrentFile) buildTrackerURL(peerID [20]byte, port uint16) (string, error) {
  base, err := url.Parse(t.Announce)
  if err != nil {
    return "", err
  }
  params := url.Values{
    "info_hash":  []string{string(t.InfoHash[:])},
    "peer_id":    []string{string(peerID[:])},
    "port":       []string{strconv.Itoa(int(Port))},
    "uploaded":   []string{"0"},
    "downloaded": []string{"0"},
    "compact":    []string{"1"},
    "left":       []string{strconv.Itoa(t.Length)},
  }
  base.RawQuery = params.Encode()
  return base.String(), nil
}

d
  8:interval
    i900e
  5:peers
    252:(another long binary blob)
e

// Peer 피어의 연결 정보를 인코딩합니다
type Peer struct {
  IP   net.IP
  Port uint16
}

// Unmarshal 버퍼에서 피어의 IP 주소와 포트 번호를 파싱합니다
func Unmarshal(peersBin []byte) ([]Peer, error) {
  const peerSize = 6 // 4 for IP, 2 for port
  numPeers := len(peersBin) / peerSize
  if len(peersBin)%peerSize != 0 {
    err := fmt.Errorf("Received malformed peers")
    return nil, err
  }
  peers := make([]Peer, numPeers)
  for i := 0; i < numPeers; i++ {
    offset := i * peerSize
    peers[i].IP = net.IP(peersBin[offset : offset+4])
    peers[i].Port = binary.BigEndian.Uint16(peersBin[offset+4 : offset+6])
  }
  return peers, nil
}

conn, err := net.DialTimeout("tcp", peer.String(), 3*time.Second)
if err != nil {
  return nil, err
}

// Handshake 피어가 자신을 식별하는 데 사용하는 특별한 메시지입니다.
type Handshake struct {
  Pstr     string
  InfoHash [20]byte
  PeerID   [20]byte
}

// Serialize 핸드셰이크를 버퍼에 직렬화합니다.
func (h *Handshake) Serialize() []byte {
  buf := make([]byte, len(h.Pstr)+49)
  buf[0] = byte(len(h.Pstr))
  curr := 1
  curr += copy(buf[curr:], h.Pstr)
  curr += copy(buf[curr:], make([]byte, 8)) // 8 reserved bytes
  curr += copy(buf[curr:], h.InfoHash[:])
  curr += copy(buf[curr:], h.PeerID[:])
  return buf
}

// Read 스트림에서 핸드셰이크를 파싱합니다.
func Read(r io.Reader) (*Handshake, error) {
  // 역직렬화 수행
  // ...
}

type messageID uint8

const (
  MsgChoke         messageID = 0
  MsgUnchoke       messageID = 1
  MsgInterested    messageID = 2
  MsgNotInterested messageID = 3
  MsgHave          messageID = 4
  MsgBitfield      messageID = 5
  MsgRequest       messageID = 6
  MsgPiece         messageID = 7
  MsgCancel        messageID = 8
)

// Message 메시지의 ID 및 페이로드를 저장합니다.
type Message struct {
  ID      messageID
  Payload []byte
}

// Serialize 메시지를 다음과 같은 형식으로 버퍼에 직렬화합니다.
// <길이 접두사><메시지 ID><페이로드>
// `nil`은 keep-live 메시지로 해석합니다.
func (m *Message) Serialize() []byte {
  if m == nil {
    return make([]byte, 4)
  }
  length := uint32(len(m.Payload) + 1) // +1 for id
  buf := make([]byte, 4+length)
  binary.BigEndian.PutUint32(buf[0:4], length)
  buf[4] = byte(m.ID)
  copy(buf[5:], m.Payload)
  return buf
}

// Read 스트림에서 메시지를 파싱합니다. keep-alive 메시지는 `nil`을 반환합니다.
func Read(r io.Reader) (*Message, error) {
  lengthBuf := make([]byte, 4)
  _, err := io.ReadFull(r, lengthBuf)
  if err != nil {
    return nil, err
  }
  length := binary.BigEndian.Uint32(lengthBuf)

  // keep-alive 메시지
  if length == 0 {
    return nil, nil
  }

  messageBuf := make([]byte, length)
  _, err = io.ReadFull(r, messageBuf)
  if err != nil {
    return nil, err
  }

  m := Message{
    ID:      messageID(messageBuf[0]),
    Payload: messageBuf[1:],
  }

  return &m, nil
}

// Bitfield 피어가 가지고 있는 조각들을 나타냅니다
type Bitfield []byte

// HasPiece 특정 인덱스를 가진 비트 필드가 설정되어 있는지 알려줍니다
func (bf Bitfield) HasPiece(index int) bool {
  byteIndex := index / 8
  offset := index % 8
  return bf[byteIndex]>>(7-offset)&1 != 0
}

// SetPiece 비트 필드에 비트를 설정합니다
func (bf Bitfield) SetPiece(index int) {
  byteIndex := index / 8
  offset := index % 8
  bf[byteIndex] |= 1 << (7 - offset)
}

// 작업자가 작업을 찾고 결과를 보낼 수 있도록 큐를 초기화합니다
workQueue := make(chan *pieceWork, len(t.PieceHashes))
results := make(chan *pieceResult)
for index, hash := range t.PieceHashes {
  length := t.calculatePieceSize(index)
  workQueue <- &pieceWork{index, hash, length}
}

// 작업을 시작합니다
for _, peer := range t.Peers {
  go t.startDownloadWorker(peer, workQueue, results)
}

// 결과가 가득 찰 때까지 버퍼로 결과를 수집합니다
buf := make([]byte, t.Length)
donePieces := 0
for donePieces < len(t.PieceHashes) {
  res := <-results
  begin, end := t.calculateBoundsForPiece(res.index)
  copy(buf[begin:end], res.buf)
  donePieces++
}
close(workQueue)

func (t *Torrent) startDownloadWorker(peer peers.Peer, workQueue chan *pieceWork, results chan *pieceResult) {
  c, err := client.New(peer, t.PeerID, t.InfoHash)
  if err != nil {
    log.Printf("Could not handshake with %s. Disconnecting\n", peer.IP)
    return
  }
  defer c.Conn.Close()
  log.Printf("Completed handshake with %s\n", peer.IP)

  c.SendUnchoke()
  c.SendInterested()

  for pw := range workQueue {
    if !c.Bitfield.HasPiece(pw.index) {
      workQueue <- pw // 큐에 조각을 다시 넣습니다
      continue
    }

    // 조각 다운로드
    buf, err := attemptDownloadPiece(c, pw)
    if err != nil {
      log.Println("Exiting", err)
      workQueue <- pw // 큐에 조각을 다시 넣습니다
      return
    }

    err = checkIntegrity(pw, buf)
    if err != nil {
      log.Printf("Piece #%d failed integrity check\n", pw.index)
      workQueue <- pw // 큐에 조각을 다시 넣습니다
      continue
    }

    c.SendHave(pw.index)
    results <- &pieceResult{pw.index, buf}
  }
}

type pieceProgress struct {
  index      int
  client     *client.Client
  buf        []byte
  downloaded int
  requested  int
  backlog    int
}

func (state *pieceProgress) readMessage() error {
  msg, err := state.client.Read() // this call blocks
  switch msg.ID {
  case message.MsgUnchoke:
    state.client.Choked = false
  case message.MsgChoke:
    state.client.Choked = true
  case message.MsgHave:
    index, err := message.ParseHave(msg)
    state.client.Bitfield.SetPiece(index)
  case message.MsgPiece:
    n, err := message.ParsePiece(state.index, state.buf, msg)
    state.downloaded += n
    state.backlog--
  }
  return nil
}

// MaxBlockSize 요청할 수 있는 최대 바이트 수
const MaxBlockSize = 16384

// MaxBacklog 클라이언트가 파이프라인에서 수행할 수 없는 요청 수입니다.
const MaxBacklog = 5

func attemptDownloadPiece(c *client.Client, pw *pieceWork) ([]byte, error) {
  state := pieceProgress{
    index:  pw.index,
    client: c,
    buf:    make([]byte, pw.length),
  }

  // 데드라인을 설정하면 응답하지 않는 피어를 떼어내는 데 도움이 됩니다
  // 262KB 조각을 다운로드하려면 30초가 충분합니다
  c.Conn.SetDeadline(time.Now().Add(30 * time.Second))
  defer c.Conn.SetDeadline(time.Time{}) // 데드라인 비활성화

  for state.downloaded < pw.length {
    // unchocked일 경우 완료되지 않은 요청이 충분히 쌓일 때까지 요청을 보냅니다.
    if !state.client.Choked {
      for state.backlog < MaxBacklog && state.requested < pw.length {
        blockSize := MaxBlockSize
        // 마지막 블록은 일반 블록보다 짧을 수 있습니다.
        if pw.length-state.requested < blockSize {
          blockSize = pw.length - state.requested
        }

        err := c.SendRequest(pw.index, state.requested, blockSize)
        if err != nil {
          return nil, err
        }
        state.backlog++
        state.requested += blockSize
      }
    }

    err := state.readMessage()
    if err != nil {
      return nil, err
    }
  }

  return state.buf, nil
}

package main

import (
    "log"
    "os"

    "github.com/veggiedefender/torrent-client/torrentfile"
)

func main() {
  inPath := os.Args[1]
  outPath := os.Args[2]

  tf, err := torrentfile.Open(inPath)
  if err != nil {
      log.Fatal(err)
  }

  err = tf.DownloadToFile(outPath)
  if err != nil {
      log.Fatal(err)
  }
}

# Go는 설치되어 있다고 가정합니다.
git clone https://github.com/veggiedefender/torrent-client.git
cd torrent-client
# linux, darwin
curl -L http://bttracker.debian.org:6969/file/debian-10.0.0-amd64-netinst.iso.torrent?info_hash=7f9161c88883c639bcde80d7f0a6045ab9cf16bb -o debian.torrent
# windows
wget http://bttracker.debian.org:6969/file/debian-10.0.0-amd64-netinst.iso.torrent?info_hash=7f9161c88883c639bcde80d7f0a6045ab9cf16bb -o debian.torrent
go run main.go debian.torrent debian.iso