Пример #1
0
  /**
   * "Parse the supplied chunk of arriving data and append it to the rcvd_blocks_ list in the given
   * bundle, finding the appropriate BlockProcessor element and calling its receive() handler.
   *
   * <p>When called repeatedly for arriving chunks of data, this properly fills in the entire
   * bundle, including the in_blocks_ record of the arriving blocks and the payload (which is stored
   * externally)." [DTN2]
   *
   * @return "the length of data consumed or -1 on protocol error, plus sets last to true if the
   *     bundle is complete." [DTN2]
   */
  public static int consume(Bundle bundle, IByteBuffer data, int len, boolean[] last) {

    int old_position = data.position();
    int origlen = len;
    last[0] = false;

    BlockInfoVec recv_blocks = bundle.recv_blocks();

    // "special case for first time we get called, since we need to
    // create a BlockInfo struct for the primary block without knowing
    // the typecode or the length" [DTN2]
    if (recv_blocks.isEmpty()) {
      BPF.getInstance()
          .getBPFLogger()
          .debug(TAG, "consume: got first block... " + "creating primary block info");
      recv_blocks.append_block(find_processor(bundle_block_type_t.PRIMARY_BLOCK), null);
    }

    // "loop as long as there is data left to process" [DTN2]
    while (len != 0) {
      BPF.getInstance()
          .getBPFLogger()
          .debug(TAG, String.format("consume: %d bytes left to process", len));
      BlockInfo info = recv_blocks.back();

      // "if the last received block is complete, create a new one
      // and push it onto the vector. at this stage we consume all
      // blocks, even if there's no BlockProcessor that understands
      // how to parse it" [DTN2]
      if (info.complete()) {
        data.mark();
        byte bundle_block_type_byte = data.get();
        bundle_block_type_t type = bundle_block_type_t.get(bundle_block_type_byte);
        data.reset();
        info = recv_blocks.append_block(find_processor(type), null);
        BPF.getInstance()
            .getBPFLogger()
            .debug(
                TAG,
                String.format(
                    "consume: previous block complete, " + "created new BlockInfo type %s",
                    info.owner().block_type()));
      }

      // "now we know that the block isn't complete, so we tell it to
      // consume a chunk of data" [DTN2]
      BPF.getInstance()
          .getBPFLogger()
          .debug(
              TAG,
              String.format(
                  "consume: block processor %s type %s incomplete, "
                      + "calling consume (%d bytes already buffered)",
                  info.owner().block_type(), info.type(), info.contents().position()));

      int cc = info.owner().consume(bundle, info, data, len);
      if (cc < 0) {
        BPF.getInstance()
            .getBPFLogger()
            .error(TAG, String.format("consume: protocol error handling block %s", info.type()));
        return -1;
      }

      // "decrement the amount that was just handled from the overall
      // total. verify that the block was either completed or
      // consumed all the data that was passed in." [DTN2]
      len -= cc;
      data.position(data.position() + cc);

      BPF.getInstance()
          .getBPFLogger()
          .debug(
              TAG,
              String.format(
                  "consume: consumed %d bytes of block type %s (%s)",
                  cc, info.type(), info.complete() ? "complete" : "not complete"));

      if (info.complete()) {
        // check if we're done with the bundle
        if ((info.flags() & block_flag_t.BLOCK_FLAG_LAST_BLOCK.getCode()) > 0) {
          last[0] = true;
          break;
        }

      } else {
        assert (len == 0);
      }
    }

    BPF.getInstance()
        .getBPFLogger()
        .debug(
            TAG,
            String.format(
                "bundle id %d consume completed, %d/%d bytes consumed %s",
                bundle.bundleid(), origlen - len, origlen, last[0] ? "(completed bundle)" : ""));

    data.position(old_position);
    return origlen - len;
  }
Пример #2
0
  /**
   * "Copies out a chunk of formatted bundle data at a specified offset from the provided
   * BlockInfoVec." [DTN2]
   *
   * @return "the length of the chunk produced (up to the supplied length) and sets last to true if
   *     the bundle is complete." [DTN2]
   */
  public static int produce(
      final Bundle bundle,
      final BlockInfoVec blocks,
      IByteBuffer data,
      int offset,
      int len,
      boolean[] last) {

    int old_position = data.position();
    int origlen = len;
    last[0] = false;

    if (len == 0) return 0;

    assert (!blocks.isEmpty());

    Iterator<BlockInfo> iter = blocks.iterator();

    BlockInfo current_block = iter.next();
    // "advance past any blocks that are skipped by the given offset."[DTN2]
    while (offset >= current_block.full_length()) {

      BPF.getInstance()
          .getBPFLogger()
          .debug(
              TAG,
              String.format(
                  "BundleProtocol::produce skipping block type %s "
                      + "since offset %d >= block length %d",
                  current_block.type().toString(), offset, current_block.full_length()));

      offset -= current_block.full_length();
      current_block = iter.next();
    }
    // "the offset value now should be within the current block" [DTN2]

    while (true) {
      // The first time remainder will be minus from leftover offset above
      // but later on it will be the full content of the block
      int remainder = current_block.full_length() - offset;
      int tocopy = Math.min(len, remainder);
      BPF.getInstance()
          .getBPFLogger()
          .debug(
              TAG,
              String.format(
                  "BundleProtocol::produce copying %d/%d bytes from "
                      + "block type %s at offset %d",
                  tocopy, remainder, current_block.type().toString(), offset));

      current_block.owner().produce(bundle, current_block, data, offset, tocopy);

      len -= tocopy;

      // move the position of IByteBuffer
      data.position(data.position() + tocopy);

      // "if we've copied out the full amount the user asked for,
      // we're done. note that we need to check the corner case
      // where we completed the block exactly to properly set the
      // last bit" [DTN2]
      if (len == 0) {
        if ((tocopy == remainder)
            && ((current_block.flags()
                    & BundleProtocol.block_flag_t.BLOCK_FLAG_LAST_BLOCK.getCode())
                > 0)) {

          last[0] = true;
        }

        break;
      }

      // "we completed the current block, so we're done if this
      // is the last block, even if there's space in the user buffer"
      // [DTN2]
      assert (tocopy == remainder);
      if ((current_block.flags() & BundleProtocol.block_flag_t.BLOCK_FLAG_LAST_BLOCK.getCode())
          > 0) {

        last[0] = true;
        break;
      }

      // advance to next block
      current_block = iter.next();
      offset = 0;
    }

    BPF.getInstance()
        .getBPFLogger()
        .debug(
            TAG,
            String.format(
                "BundleProtocol::produce complete: "
                    + "produced %d bytes, bundle id %d, status is  %s",
                origlen - len, bundle.bundleid(), last[0] ? "complete" : "not complete"));

    data.position(old_position);
    return origlen - len;
  }