formatting

internal/message.go

@@ -12,100 +12,100 @@ import (
 
 type messageID uint8
 type Message struct {
- ID messageID
- Payload []byte
+ ID messageID
+ Payload []byte
 }
 
 const (
- HandshakeExtendedID uint8 = 0
- RequestMetadataExtensionMsgType uint8 = 0
- DataMetadataExtensionMsgType uint8 = 1
+ HandshakeExtendedID uint8 = 0
+ RequestMetadataExtensionMsgType uint8 = 0
+ DataMetadataExtensionMsgType uint8 = 1
 
- MsgBitfield messageID = 5
- MsgExtended messageID = 20
+ MsgBitfield messageID = 5
+ MsgExtended messageID = 20
 )
 
 func sendBitfieldMessage(conn net.Conn, payload []byte, logger *logger.Logger) (err error) {
- defer logOnExit(logger, &err)
+ defer logOnExit(logger, &err)
 
- logger.Debugln("Sending bitfield message")
- req := Message { ID: MsgBitfield, Payload: payload }
- serialized := req.Serialize()
- _, err = conn.Write(serialized)
- return err
+ logger.Debugln("Sending bitfield message")
+ req := Message { ID: MsgBitfield, Payload: payload }
+ serialized := req.Serialize()
+ _, err = conn.Write(serialized)
+ return err
 }
 
 // Serialize serializes a message into a buffer of the form
 // <length prefix><message ID><payload>
 // Interprets `nil` as a keep-alive message
 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
+ 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
 }
 
 func sendExtensionHandshake(conn net.Conn, metadataID uint8, metadataSize int, logger *logger.Logger) (err error) {
- defer logOnExit(logger, &err)
+ defer logOnExit(logger, &err)
 
- logger.Debugln("Sending extension handshake")
- req := createExtensionHandshake(metadataID, metadataSize, logger)
- serialized := req.Serialize()
- _, err = conn.Write(serialized)
- return err
+ logger.Debugln("Sending extension handshake")
+ req := createExtensionHandshake(metadataID, metadataSize, logger)
+ serialized := req.Serialize()
+ _, err = conn.Write(serialized)
+ return err
 }
 
 func createExtensionHandshake(metadataID uint8, metadataSize int, logger *logger.Logger) *Message {
- dict := make(map[string]interface{})
- inner := make(map[string]int64)
- inner["ut_metadata"] = int64(metadataID)
- dict["m"] = inner
- dict["metadata_size"] = metadataSize
- var buf bytes.Buffer
- err := bencode.Marshal(&buf, dict)
- if err != nil {
- logger.Errorf("Error encoding: %v", err)
- }
- payload := formatExtendedPayload(buf, HandshakeExtendedID)
- return &Message{ID: MsgExtended, Payload: payload}
+ dict := make(map[string]interface{})
+ inner := make(map[string]int64)
+ inner["ut_metadata"] = int64(metadataID)
+ dict["m"] = inner
+ dict["metadata_size"] = metadataSize
+ var buf bytes.Buffer
+ err := bencode.Marshal(&buf, dict)
+ if err != nil {
+ logger.Errorf("Error encoding: %v", err)
+ }
+ payload := formatExtendedPayload(buf, HandshakeExtendedID)
+ return &Message{ID: MsgExtended, Payload: payload}
 }
 
 func formatExtendedPayload(buf bytes.Buffer, extensionId uint8) []byte {
- payload := make([]byte, 1+buf.Len())
- payload[0] = uint8(extensionId)
- copy(payload[1:], buf.Bytes())
- return payload
+ payload := make([]byte, 1+buf.Len())
+ payload[0] = uint8(extensionId)
+ copy(payload[1:], buf.Bytes())
+ return payload
 }
 
 // Read parses a message from a stream. Returns `nil` on keep-alive message
 func readMessage(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 message
- 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
+ lengthBuf := make([]byte, 4)
+ _, err := io.ReadFull(r, lengthBuf)
+ if err != nil {
+ return nil, err
+ }
+ length := binary.BigEndian.Uint32(lengthBuf)
+
+ // keep-alive message
+ 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
 }

internal/stage_helpers.go

@@ -52,6 +52,16 @@ var samplePieceHashes = []string{
  "aec2d7eb1db539c2a9d24d023fb916b79234b769",
 }
 
+type TestTorrentInfo struct {
+ filename string
+ outputFilename string
+ tracker string
+ infohash string
+ length int64
+ expectedSha1 string
+ incorrectSha1 []string
+}
+
 var testTorrents = []TestTorrentInfo{
  {
  filename: "codercat.gif.torrent",

internal/stage_magnet_helpers.go

@@ -13,53 +13,28 @@ import (
 )
 
 type MagnetTestParams struct {
- TrackerAddress  string
- PeerPort  int
- PeerAddress  string
- PeersResponse  []byte
- ExpectedInfoHash  [20]byte
- ExpectedReservedBytes  []byte
- ExpectedPeerID  [20]byte
- MyMetadataExtensionID  uint8
- MagnetUrlEncoded string
- MagnetLinkInfo MagnetTestTorrentInfo
- Logger  *logger.Logger
+ TrackerAddress  string
+ PeerPort  int
+ PeerAddress  string
+ PeersResponse  []byte
+ ExpectedInfoHash  [20]byte
+ ExpectedReservedBytes  []byte
+ ExpectedPeerID  [20]byte
+ MyMetadataExtensionID  uint8
+ MagnetUrlEncoded string
+ MagnetLinkInfo MagnetTestTorrentInfo
+ Logger  *logger.Logger
 }
 
 type MagnetTestTorrentInfo struct {
- Filename string
- InfoHashStr string
- FileLengthBytes int
- PieceLengthBytes int
- MetadataSizeBytes int
- Bitfield []byte
- PieceHashes []string
- ExpectedSha1 string
-}
-
-func (m *MagnetTestParams) toTrackerParams() TrackerParams {
- return TrackerParams {
- trackerAddress: m.TrackerAddress,
- peersResponse: m.PeersResponse,
- expectedInfoHash: m.ExpectedInfoHash,
- fileLengthBytes: m.MagnetLinkInfo.FileLengthBytes,
- logger: m.Logger,
- myMetadataExtensionID: m.MyMetadataExtensionID,
- }
-}
-
-func (m *MagnetTestParams) toPeerConnectionParams() PeerConnectionParams {
- return PeerConnectionParams {
- address: m.PeerAddress,
- myPeerID: m.ExpectedPeerID,
- infoHash: m.ExpectedInfoHash,
- expectedReservedBytes: m.ExpectedReservedBytes,
- myMetadataExtensionID: m.MyMetadataExtensionID,
- metadataSizeBytes: m.MagnetLinkInfo.MetadataSizeBytes,
- bitfield: m.MagnetLinkInfo.Bitfield,
- magnetLink: m.MagnetLinkInfo,
- logger: m.Logger,
- }
+ Filename string
+ InfoHashStr string
+ FileLengthBytes int
+ PieceLengthBytes int
+ MetadataSizeBytes int
+ Bitfield []byte
+ PieceHashes []string
+ ExpectedSha1 string
 }
 
 var magnetTestTorrents = []MagnetTestTorrentInfo {
@@ -105,6 +80,31 @@ var magnetTestTorrents = []MagnetTestTorrentInfo {
  },
 }
 
+func (m *MagnetTestParams) toTrackerParams() TrackerParams {
+ return TrackerParams {
+ trackerAddress: m.TrackerAddress,
+ peersResponse: m.PeersResponse,
+ expectedInfoHash: m.ExpectedInfoHash,
+ fileLengthBytes: m.MagnetLinkInfo.FileLengthBytes,
+ logger: m.Logger,
+ myMetadataExtensionID: m.MyMetadataExtensionID,
+ }
+}
+
+func (m *MagnetTestParams) toPeerConnectionParams() PeerConnectionParams {
+ return PeerConnectionParams {
+ address: m.PeerAddress,
+ myPeerID: m.ExpectedPeerID,
+ infoHash: m.ExpectedInfoHash,
+ expectedReservedBytes: m.ExpectedReservedBytes,
+ myMetadataExtensionID: m.MyMetadataExtensionID,
+ metadataSizeBytes: m.MagnetLinkInfo.MetadataSizeBytes,
+ bitfield: m.MagnetLinkInfo.Bitfield,
+ magnetLink: m.MagnetLinkInfo,
+ logger: m.Logger,
+ }
+}
+
 func NewMagnetTestParams(magnetLink MagnetTestTorrentInfo, logger *logger.Logger) (*MagnetTestParams, error) {
  params := MagnetTestParams{}
 
@@ -122,6 +122,7 @@ func NewMagnetTestParams(magnetLink MagnetTestTorrentInfo, logger *logger.Logger
  }
  trackerAddress := fmt.Sprintf("127.0.0.1:%d", trackerPort)
  params.TrackerAddress = trackerAddress
+
  infoHashStr := magnetLink.InfoHashStr
  params.MagnetUrlEncoded = "magnet:?xt=urn:btih:" + infoHashStr + "&dn=" + magnetLink.Filename + "&tr=http%3A%2F%2F" + trackerAddress + "%2Fannounce"
 

internal/stage_magnet_send.go

@@ -22,10 +22,10 @@ func testMagnetSendExtendedHandshake(stageHarness *test_case_harness.TestCaseHar
  return err
  }
 
- go listenAndServePeersResponse(params.toTrackerParams())
+ go listenAndServeTrackerResponse(params.toTrackerParams())
  go waitAndHandlePeerConnection(params.toPeerConnectionParams(), handleSendExtensionHandshake)
 
- logger.Infof("Running ./your_bittorrent.sh magnet_handshake %s", escape(params.MagnetUrlEncoded))
+ logger.Infof("Running ./your_bittorrent.sh magnet_handshake %q", params.MagnetUrlEncoded)
  result, err := executable.Run("magnet_handshake", params.MagnetUrlEncoded)
  if err != nil {
  return err