@Override
  public DirectByteBuffer[] getData() {
    try {
      if (buffer == null) {
        if (msg_type == REQUEST_MESSAGE_TYPE_ID) {
          Map<Object, Object> map = new HashMap<Object, Object>();
          map.put("msg_type", msg_type);
          map.put("piece", piece);
          buffer =
              MessagingUtil.convertPayloadToBencodedByteStream(
                  map, DirectByteBuffer.AL_MSG_UT_METADATA);
        } else if (msg_type == DATA_MESSAGE_TYPE_ID) {
          Map<Object, Object> map = new HashMap<Object, Object>();
          map.put("msg_type", msg_type);
          map.put("piece", piece);
          map.put("total_size", total_size);
          byte[] mapPayload = BEncoder.encode(map);
          buffer =
              DirectByteBufferPool.getBuffer(
                  DirectByteBuffer.AL_MSG_UT_METADATA, mapPayload.length + metadata.length);
          buffer.put(DirectByteBuffer.SS_MSG, mapPayload);
          buffer.put(DirectByteBuffer.SS_MSG, metadata);
          buffer.flip(DirectByteBuffer.SS_MSG);
        } else if (msg_type == REJECT_MESSAGE_TYPE_ID) {
          Map<Object, Object> map = new HashMap<Object, Object>();
          map.put("msg_type", msg_type);
          map.put("piece", piece);
          buffer =
              MessagingUtil.convertPayloadToBencodedByteStream(
                  map, DirectByteBuffer.AL_MSG_UT_METADATA);
        } else {
          if (Logger.isEnabled()) {
            Logger.log(
                new LogEvent(
                    LOGID, LogEvent.LT_ERROR, "METADATA (UT): No valid msg_type=" + msg_type));
          }
          return null;
        }
      }

      return new DirectByteBuffer[] {buffer};
    } catch (Throwable e) {
      // what is the best way to handle this error?
      if (Logger.isEnabled()) {
        Logger.log(new LogEvent(LOGID, LogEvent.LT_ERROR, "METADATA (UT)", e));
      }
      return new DirectByteBuffer[0];
    }
  }
示例#2
0
    private static byte[] getDummyPacket() throws IOException {
      DirectByteBuffer dbuffer =
          DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG, OSF2FMessage.MAX_PAYLOAD_SIZE);
      while (dbuffer.hasRemaining(DirectByteBuffer.SS_NET)) {
        dbuffer.put(DirectByteBuffer.SS_NET, (byte) 0);
      }
      dbuffer.flip(DirectByteBuffer.SS_NET);

      DirectByteBuffer[] data =
          OSF2FMessageFactory.createOSF2FRawMessage(
                  new OSF2FChannelDataMsg(OSF2FMessage.CURRENT_VERSION, 0, -1, dbuffer))
              .getRawData();
      ByteBuffer buf = ByteBuffer.allocate(OSF2FMessage.MAX_MESSAGE_SIZE + 20);
      for (int i = 0; i < data.length; i++) {
        buf.put(data[i].getBuffer(DirectByteBuffer.SS_MSG));
      }
      buf.flip();
      byte[] b = new byte[buf.remaining()];
      buf.get(b);
      return b;
    }
public class BTMessageDecoder implements MessageStreamDecoder {
  private static final int MIN_MESSAGE_LENGTH = 1; // for type id
  // private static final int MAX_MESSAGE_LENGTH = 16*1024+128;  //should never be > 16KB+9B, as we
  // never request chunks > 16KB - update, some LT extensions can be bigger
  private static final int MAX_MESSAGE_LENGTH =
      128
          * 1024; // 17/5/2013: parg: got a huge torrent with so many pieces the bitfield exceeds
                  // the above limit...
  private static final int HANDSHAKE_FAKE_LENGTH =
      323119476; // (byte)19 + "Bit" readInt() value of header

  private static final byte SS = DirectByteBuffer.SS_MSG;

  private DirectByteBuffer payload_buffer = null;
  private final DirectByteBuffer length_buffer =
      DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG, 4);
  private final ByteBuffer[] decode_array = new ByteBuffer[] {null, length_buffer.getBuffer(SS)};

  private boolean reading_length_mode = true;
  private boolean reading_handshake_message = false;

  private int message_length;
  private int pre_read_start_buffer;
  private int pre_read_start_position;

  private boolean last_received_was_keepalive = false;

  private volatile boolean destroyed = false;
  private volatile boolean is_paused = false;

  private ArrayList messages_last_read = new ArrayList();
  private int protocol_bytes_last_read = 0;
  private int data_bytes_last_read = 0;
  private int percent_complete = -1;

  public BTMessageDecoder() {
    /* nothing */
  }

  public int performStreamDecode(Transport transport, int max_bytes) throws IOException {
    try {
      protocol_bytes_last_read = 0;
      data_bytes_last_read = 0;

      int bytes_remaining = max_bytes;

      while (bytes_remaining > 0) {

        if (destroyed) {

          // destruction currently isn't thread safe so one thread can destroy the decoder (e.g.
          // when closing a connection)
          // while the read-controller is still actively processing the us
          // throw( new IOException( "BTMessageDecoder already destroyed" ));
          break;
        }

        if (is_paused) {
          break;
        }

        int bytes_possible = preReadProcess(bytes_remaining);

        if (bytes_possible < 1) {
          Debug.out("ERROR BT: bytes_possible < 1");
          break;
        }

        if (reading_length_mode) {
          transport.read(decode_array, 1, 1); // only read into length buffer
        } else {
          transport.read(
              decode_array, 0, 2); // read into payload buffer, and possibly next message length
        }

        int bytes_read = postReadProcess();

        bytes_remaining -= bytes_read;

        if (bytes_read < bytes_possible) {
          break;
        }

        if (reading_length_mode && last_received_was_keepalive) {
          // hack to stop a 0-byte-read after receiving a keep-alive message
          // otherwise we won't realize there's nothing left on the line until trying to read again
          last_received_was_keepalive = false;
          break;
        }
      }

      return max_bytes - bytes_remaining;

    } catch (NullPointerException e) {

      // due to lack of synchronization here the buffers can be nullified by a concurrent 'destroy'
      // turn this into something less scarey

      throw (new IOException("Decoder has most likely been destroyed"));
    }
  }

  public int getPercentDoneOfCurrentMessage() {
    return percent_complete;
  }

  public Message[] removeDecodedMessages() {
    if (messages_last_read.isEmpty()) return null;

    Message[] msgs = (Message[]) messages_last_read.toArray(new Message[messages_last_read.size()]);

    messages_last_read.clear();

    return msgs;
  }

  public int getProtocolBytesDecoded() {
    return protocol_bytes_last_read;
  }

  public int getDataBytesDecoded() {
    return data_bytes_last_read;
  }

  public ByteBuffer destroy() {
    if (destroyed) {
      Debug.out("Trying to redestroy message decoder, stack trace follows: " + this);
      Debug.outStackTrace();
    }

    is_paused = true;
    destroyed = true;

    // there's a concurrency issue with the decoder whereby it can be destroyed while will being
    // messed with. Don't
    // have the energy to look into it properly atm so just try to ensure that it doesn't bork too
    // badly (parg: 29/04/2012)
    // only occasional but does have potential to generate direct buffer mem leak ;(

    int lbuff_read = 0;
    int pbuff_read = 0;
    length_buffer.limit(SS, 4);

    DirectByteBuffer plb = payload_buffer;

    if (reading_length_mode) {
      lbuff_read = length_buffer.position(SS);
    } else { // reading payload
      length_buffer.position(SS, 4);
      lbuff_read = 4;
      pbuff_read = plb == null ? 0 : plb.position(SS);
    }

    ByteBuffer unused = ByteBuffer.allocate(lbuff_read + pbuff_read); // TODO convert to direct?

    length_buffer.flip(SS);
    unused.put(length_buffer.getBuffer(SS));

    try {
      if (plb != null) {
        plb.flip(SS);
        unused.put(
            plb.getBuffer(
                SS)); // Got a buffer overflow exception here in the past - related to PEX?
      }
    } catch (RuntimeException e) {
      Debug.out("hit known threading issue");
    }

    unused.flip();

    length_buffer.returnToPool();

    if (plb != null) {
      plb.returnToPool();
      payload_buffer = null;
    }

    try {
      for (int i = 0; i < messages_last_read.size(); i++) {
        Message msg = (Message) messages_last_read.get(i);
        msg.destroy();
      }
    } catch (RuntimeException e) {
      // happens if messages modified by alt thread...
      Debug.out("hit known threading issue");
    }
    messages_last_read.clear();

    return unused;
  }

  private int preReadProcess(int allowed) {
    if (allowed < 1) {
      Debug.out("allowed < 1");
    }

    decode_array[0] =
        payload_buffer == null
            ? null
            : payload_buffer.getBuffer(
                SS); // ensure the decode array has the latest payload pointer

    int bytes_available = 0;
    boolean shrink_remaining_buffers = false;
    int start_buff = reading_length_mode ? 1 : 0;
    boolean marked = false;

    for (int i = start_buff; i < 2; i++) { // set buffer limits according to bytes allowed
      ByteBuffer bb = decode_array[i];

      if (bb == null) {
        Debug.out("preReadProcess:: bb[" + i + "] == null, decoder destroyed=" + destroyed);

        throw (new RuntimeException("decoder destroyed"));
      }

      if (shrink_remaining_buffers) {
        bb.limit(0); // ensure no read into this next buffer is possible
      } else {
        int remaining = bb.remaining();

        if (remaining < 1) continue; // skip full buffer

        if (!marked) {
          pre_read_start_buffer = i;
          pre_read_start_position = bb.position();
          marked = true;
        }

        if (remaining > allowed) { // read only part of this buffer
          bb.limit(bb.position() + allowed); // limit current buffer
          bytes_available += bb.remaining();
          shrink_remaining_buffers = true; // shrink any tail buffers
        } else { // full buffer is allowed to be read
          bytes_available += remaining;
          allowed -= remaining; // count this buffer toward allowed and move on to the next
        }
      }
    }

    return bytes_available;
  }

  private int postReadProcess() throws IOException {
    int prot_bytes_read = 0;
    int data_bytes_read = 0;

    if (!reading_length_mode && !destroyed) { // reading payload data mode
      // ensure-restore proper buffer limits
      payload_buffer.limit(SS, message_length);
      length_buffer.limit(SS, 4);

      int read = payload_buffer.position(SS) - pre_read_start_position;

      if (payload_buffer.position(SS) > 0) { // need to have read the message id first byte
        if (BTMessageFactory.getMessageType(payload_buffer) == Message.TYPE_DATA_PAYLOAD) {
          data_bytes_read += read;
        } else {
          prot_bytes_read += read;
        }
      }

      if (!payload_buffer.hasRemaining(SS) && !is_paused) { // full message received!
        payload_buffer.position(SS, 0);

        DirectByteBuffer ref_buff = payload_buffer;
        payload_buffer = null;

        if (reading_handshake_message) { // decode handshake
          reading_handshake_message = false;

          DirectByteBuffer handshake_data =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_HAND, 68);
          handshake_data.putInt(SS, HANDSHAKE_FAKE_LENGTH);
          handshake_data.put(SS, ref_buff);
          handshake_data.flip(SS);

          ref_buff.returnToPool();

          try {
            Message handshake =
                MessageManager.getSingleton()
                    .createMessage(BTMessage.ID_BT_HANDSHAKE_BYTES, handshake_data, (byte) 1);
            messages_last_read.add(handshake);
          } catch (MessageException me) {
            handshake_data.returnToPool();
            throw new IOException("BT message decode failed: " + me.getMessage());
          }

          // we need to auto-pause decoding until we're told to start again externally,
          // as we don't want to accidentally read the next message on the stream if it's an
          // AZ-format handshake
          pauseDecoding();
        } else { // decode normal message
          try {
            messages_last_read.add(createMessage(ref_buff));
          } catch (Throwable e) {
            ref_buff.returnToPoolIfNotFree();

            // maintain unexpected errors as such so they get logged later

            if (e instanceof RuntimeException) {

              throw ((RuntimeException) e);
            }

            throw new IOException("BT message decode failed: " + e.getMessage());
          }
        }

        reading_length_mode = true; // see if we've already read the next message's length
        percent_complete = -1; // reset receive percentage
      } else { // only partial received so far
        percent_complete =
            (payload_buffer.position(SS) * 100) / message_length; // compute receive percentage
      }
    }

    if (reading_length_mode && !destroyed) {
      length_buffer.limit(SS, 4); // ensure proper buffer limit

      prot_bytes_read +=
          (pre_read_start_buffer == 1)
              ? length_buffer.position(SS) - pre_read_start_position
              : length_buffer.position(SS);

      if (!length_buffer.hasRemaining(SS)) { // done reading the length
        reading_length_mode = false;

        length_buffer.position(SS, 0);
        message_length = length_buffer.getInt(SS);

        length_buffer.position(SS, 0); // reset it for next length read

        if (message_length == HANDSHAKE_FAKE_LENGTH) { // handshake message
          reading_handshake_message = true;
          message_length = 64; // restore 'real' length
          payload_buffer =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_HAND, message_length);
        } else if (message_length == 0) { // keep-alive message
          reading_length_mode = true;
          last_received_was_keepalive = true;

          try {
            Message keep_alive =
                MessageManager.getSingleton()
                    .createMessage(BTMessage.ID_BT_KEEP_ALIVE_BYTES, null, (byte) 1);
            messages_last_read.add(keep_alive);
          } catch (MessageException me) {
            throw new IOException("BT message decode failed: " + me.getMessage());
          }
        } else if (message_length < MIN_MESSAGE_LENGTH || message_length > MAX_MESSAGE_LENGTH) {
          throw new IOException(
              "Invalid message length given for BT message decode: " + message_length);
        } else { // normal message
          payload_buffer =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_PAYLOAD, message_length);
        }
      }
    }

    protocol_bytes_last_read += prot_bytes_read;
    data_bytes_last_read += data_bytes_read;

    return prot_bytes_read + data_bytes_read;
  }

  public void pauseDecoding() {
    is_paused = true;
  }

  public void resumeDecoding() {
    is_paused = false;
  }

  // Overridden by LTMessageDecoder.
  protected Message createMessage(DirectByteBuffer ref_buff) throws MessageException {
    try {
      return BTMessageFactory.createBTMessage(ref_buff);
    } catch (MessageException me) {
      /*if (identifier != null && me.getMessage() != null && me.getMessage().startsWith("Unknown BT message id")) {
       System.out.println(identifier + " " + me.getMessage());
      }*/
      throw me;
    }
  }
}
  private int postReadProcess() throws IOException {
    int prot_bytes_read = 0;
    int data_bytes_read = 0;

    if (!reading_length_mode && !destroyed) { // reading payload data mode
      // ensure-restore proper buffer limits
      payload_buffer.limit(SS, message_length);
      length_buffer.limit(SS, 4);

      int read = payload_buffer.position(SS) - pre_read_start_position;

      if (payload_buffer.position(SS) > 0) { // need to have read the message id first byte
        if (BTMessageFactory.getMessageType(payload_buffer) == Message.TYPE_DATA_PAYLOAD) {
          data_bytes_read += read;
        } else {
          prot_bytes_read += read;
        }
      }

      if (!payload_buffer.hasRemaining(SS) && !is_paused) { // full message received!
        payload_buffer.position(SS, 0);

        DirectByteBuffer ref_buff = payload_buffer;
        payload_buffer = null;

        if (reading_handshake_message) { // decode handshake
          reading_handshake_message = false;

          DirectByteBuffer handshake_data =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_HAND, 68);
          handshake_data.putInt(SS, HANDSHAKE_FAKE_LENGTH);
          handshake_data.put(SS, ref_buff);
          handshake_data.flip(SS);

          ref_buff.returnToPool();

          try {
            Message handshake =
                MessageManager.getSingleton()
                    .createMessage(BTMessage.ID_BT_HANDSHAKE_BYTES, handshake_data, (byte) 1);
            messages_last_read.add(handshake);
          } catch (MessageException me) {
            handshake_data.returnToPool();
            throw new IOException("BT message decode failed: " + me.getMessage());
          }

          // we need to auto-pause decoding until we're told to start again externally,
          // as we don't want to accidentally read the next message on the stream if it's an
          // AZ-format handshake
          pauseDecoding();
        } else { // decode normal message
          try {
            messages_last_read.add(createMessage(ref_buff));
          } catch (Throwable e) {
            ref_buff.returnToPoolIfNotFree();

            // maintain unexpected errors as such so they get logged later

            if (e instanceof RuntimeException) {

              throw ((RuntimeException) e);
            }

            throw new IOException("BT message decode failed: " + e.getMessage());
          }
        }

        reading_length_mode = true; // see if we've already read the next message's length
        percent_complete = -1; // reset receive percentage
      } else { // only partial received so far
        percent_complete =
            (payload_buffer.position(SS) * 100) / message_length; // compute receive percentage
      }
    }

    if (reading_length_mode && !destroyed) {
      length_buffer.limit(SS, 4); // ensure proper buffer limit

      prot_bytes_read +=
          (pre_read_start_buffer == 1)
              ? length_buffer.position(SS) - pre_read_start_position
              : length_buffer.position(SS);

      if (!length_buffer.hasRemaining(SS)) { // done reading the length
        reading_length_mode = false;

        length_buffer.position(SS, 0);
        message_length = length_buffer.getInt(SS);

        length_buffer.position(SS, 0); // reset it for next length read

        if (message_length == HANDSHAKE_FAKE_LENGTH) { // handshake message
          reading_handshake_message = true;
          message_length = 64; // restore 'real' length
          payload_buffer =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_HAND, message_length);
        } else if (message_length == 0) { // keep-alive message
          reading_length_mode = true;
          last_received_was_keepalive = true;

          try {
            Message keep_alive =
                MessageManager.getSingleton()
                    .createMessage(BTMessage.ID_BT_KEEP_ALIVE_BYTES, null, (byte) 1);
            messages_last_read.add(keep_alive);
          } catch (MessageException me) {
            throw new IOException("BT message decode failed: " + me.getMessage());
          }
        } else if (message_length < MIN_MESSAGE_LENGTH || message_length > MAX_MESSAGE_LENGTH) {
          throw new IOException(
              "Invalid message length given for BT message decode: " + message_length);
        } else { // normal message
          payload_buffer =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_MSG_BT_PAYLOAD, message_length);
        }
      }
    }

    protocol_bytes_last_read += prot_bytes_read;
    data_bytes_last_read += data_bytes_read;

    return prot_bytes_read + data_bytes_read;
  }
  protected void convert(int target_type) throws FMFileManagerException {

    if (type == target_type) {

      return;
    }

    if (type == FMFile.FT_PIECE_REORDER || target_type == FMFile.FT_PIECE_REORDER) {

      if (target_type == FMFile.FT_PIECE_REORDER_COMPACT
          || type == FMFile.FT_PIECE_REORDER_COMPACT) {

        // these two access modes are in fact identical at the moment

        type = target_type;

        return;
      }

      throw (new FMFileManagerException("Conversion to/from piece-reorder not supported"));
    }

    File file = owner.getLinkedFile();

    RandomAccessFile raf = null;

    boolean ok = false;

    try {
      FMFileAccess target_access;

      if (target_type == FMFile.FT_LINEAR) {

        target_access = new FMFileAccessLinear(owner);

      } else {

        target_access =
            new FMFileAccessCompact(
                owner.getOwner().getTorrentFile(),
                control_dir,
                controlFileName,
                new FMFileAccessLinear(owner));
      }

      if (file.exists()) {

        raf = new RandomAccessFile(file, FMFileImpl.WRITE_ACCESS_MODE);

        // due to the simplistic implementation of compact we only actually need to deal with
        // the last piece of the file (first piece is in the right place already)

        FMFileAccessCompact compact_access;

        if (target_type == FMFile.FT_LINEAR) {

          compact_access = (FMFileAccessCompact) file_access;

        } else {

          compact_access = (FMFileAccessCompact) target_access;
        }

        long length = file_access.getLength(raf);

        long last_piece_start = compact_access.getLastPieceStart();
        long last_piece_length = compact_access.getLastPieceLength();

        // see if we have any potential data for the last piece

        if (last_piece_length > 0 && length > last_piece_start) {

          long data_length = length - last_piece_start;

          if (data_length > last_piece_length) {

            Debug.out(
                "data length inconsistent: len=" + data_length + ",limit=" + last_piece_length);

            data_length = last_piece_length;
          }

          DirectByteBuffer buffer =
              DirectByteBufferPool.getBuffer(DirectByteBuffer.AL_FILE, (int) data_length);

          try {

            file_access.read(raf, new DirectByteBuffer[] {buffer}, last_piece_start);

            // see if we need to truncate

            if (target_type == FMFile.FT_COMPACT) {

              long first_piece_length = compact_access.getFirstPieceLength();

              long physical_length = raf.length();

              if (physical_length > first_piece_length) {

                raf.setLength(first_piece_length);
              }
            }

            buffer.flip(DirectByteBuffer.AL_FILE);

            target_access.write(raf, new DirectByteBuffer[] {buffer}, last_piece_start);

          } finally {

            buffer.returnToPool();
          }
        } else {

          // no last piece, truncate after the first piece

          if (target_type == FMFile.FT_COMPACT) {

            long first_piece_length = compact_access.getFirstPieceLength();

            long physical_length = raf.length();

            if (physical_length > first_piece_length) {

              raf.setLength(first_piece_length);
            }
          }
        }

        target_access.setLength(raf, length);

        target_access.flush();
      }

      type = target_type;
      file_access = target_access;

      ok = true;

    } catch (Throwable e) {

      Debug.printStackTrace(e);

      throw (new FMFileManagerException("convert fails", e));

    } finally {

      try {
        if (raf != null) {

          try {
            raf.close();

          } catch (Throwable e) {

            // override original exception if there isn't one

            if (ok) {

              ok = false;

              throw (new FMFileManagerException("convert fails", e));
            }
          }
        }
      } finally {

        if (!ok) {

          // conversion failed - replace with linear access, caller is responsible for
          // handling this (marking file requiring recheck)

          type = FMFile.FT_LINEAR;
          file_access = new FMFileAccessLinear(owner);
        }

        if (type == FMFile.FT_LINEAR) {

          new File(control_dir, controlFileName).delete();
        }
      }
    }
  }