示例#1
0
  // Attach to pid and perform a thread dump
  private static void runThreadDump(String pid, String args[]) throws Exception {
    VirtualMachine vm = null;
    try {
      vm = VirtualMachine.attach(pid);
    } catch (Exception x) {
      String msg = x.getMessage();
      if (msg != null) {
        System.err.println(pid + ": " + msg);
      } else {
        x.printStackTrace();
      }
      if ((x instanceof AttachNotSupportedException) && (loadSAClass() != null)) {
        System.err.println(
            "The -F option can be used when the target " + "process is not responding");
      }
      System.exit(1);
    }

    // Cast to HotSpotVirtualMachine as this is implementation specific
    // method.
    InputStream in = ((HotSpotVirtualMachine) vm).remoteDataDump((Object[]) args);

    // read to EOF and just print output
    byte b[] = new byte[256];
    int n;
    do {
      n = in.read(b);
      if (n > 0) {
        String s = new String(b, 0, n, "UTF-8");
        System.out.print(s);
      }
    } while (n > 0);
    in.close();
    vm.detach();
  }
示例#2
0
  public SF2Soundbank(URL url) throws IOException {

    InputStream is = url.openStream();
    try {
      readSoundbank(is);
    } finally {
      is.close();
    }
  }
示例#3
0
 public SF2Soundbank(File file) throws IOException {
   largeFormat = true;
   sampleFile = file;
   InputStream is = new FileInputStream(file);
   try {
     readSoundbank(is);
   } finally {
     is.close();
   }
 }
示例#4
0
 private void fill() throws IOException {
   if (!seenEOF) {
     if (pos > 0 && pos < limit) {
       System.arraycopy(inbuf, pos, inbuf, 0, limit - pos);
       limit = limit - pos;
       pos = 0;
     } else if (pos >= limit) {
       pos = 0;
       limit = 0;
     }
     int bsize = inbuf.length;
     while (limit < bsize) {
       int n = underlyingInputStream.read(inbuf, limit, bsize - limit);
       if (n <= 0) {
         seenEOF = true;
         break;
       }
       limit += n;
     }
   }
 }
示例#5
0
  /**
   * Constructs a MessageToken from an InputStream. Bytes will be read on demand and the thread
   * might block if there are not enough bytes to complete the token. Please note there is no
   * accurate way to find out the size of a token, but we try our best to make sure there is enough
   * bytes to construct one.
   *
   * @param tokenId the token id that should be contained in this token as it is read.
   * @param context the Kerberos context associated with this token
   * @param is the InputStream from which to read
   * @param prop the MessageProp structure in which the properties of the token should be stored.
   * @throws GSSException if there is a problem reading from the InputStream or parsing the token
   */
  MessageToken_v2(int tokenId, Krb5Context context, InputStream is, MessageProp prop)
      throws GSSException {
    init(tokenId, context);

    try {
      if (!confState) {
        prop.setPrivacy(false);
      }
      tokenHeader = new MessageTokenHeader(is, prop, tokenId);

      // set key_usage
      if (tokenId == Krb5Token.WRAP_ID_v2) {
        key_usage = (!initiator ? KG_USAGE_INITIATOR_SEAL : KG_USAGE_ACCEPTOR_SEAL);
      } else if (tokenId == Krb5Token.MIC_ID_v2) {
        key_usage = (!initiator ? KG_USAGE_INITIATOR_SIGN : KG_USAGE_ACCEPTOR_SIGN);
      }

      int minSize = 0; // minimal size for token data
      if (tokenId == Krb5Token.WRAP_ID_v2 && prop.getPrivacy()) {
        minSize = CONFOUNDER_SIZE + TOKEN_HEADER_SIZE + cipherHelper.getChecksumLength();
      } else {
        minSize = cipherHelper.getChecksumLength();
      }

      // Read token data
      if (tokenId == Krb5Token.MIC_ID_v2) {
        // The only case we can precisely predict the token data length
        tokenDataLen = minSize;
        tokenData = new byte[minSize];
        readFully(is, tokenData);
      } else {
        tokenDataLen = is.available();
        if (tokenDataLen >= minSize) { // read in one shot
          tokenData = new byte[tokenDataLen];
          readFully(is, tokenData);
        } else {
          byte[] tmp = new byte[minSize];
          readFully(is, tmp);
          // Hope while blocked in the read above, more data would
          // come and is.available() below contains the whole token.
          int more = is.available();
          tokenDataLen = minSize + more;
          tokenData = Arrays.copyOf(tmp, tokenDataLen);
          readFully(is, tokenData, minSize, more);
        }
      }

      if (tokenId == Krb5Token.WRAP_ID_v2) {
        rotate();
      }

      if (tokenId == Krb5Token.MIC_ID_v2
          || (tokenId == Krb5Token.WRAP_ID_v2 && !prop.getPrivacy())) {
        // Read checksum
        int chkLen = cipherHelper.getChecksumLength();
        checksum = new byte[chkLen];
        System.arraycopy(tokenData, tokenDataLen - chkLen, checksum, 0, chkLen);

        // validate EC for Wrap tokens without confidentiality
        if (tokenId == Krb5Token.WRAP_ID_v2 && !prop.getPrivacy()) {
          if (chkLen != ec) {
            throw new GSSException(
                GSSException.DEFECTIVE_TOKEN, -1, getTokenName(tokenId) + ":" + "EC incorrect!");
          }
        }
      }
    } catch (IOException e) {
      throw new GSSException(
          GSSException.DEFECTIVE_TOKEN, -1, getTokenName(tokenId) + ":" + e.getMessage());
    }
  }
示例#6
0
  /* this is changed
  public void run() {
  */
  public void produceImage() throws IOException, ImageFormatException {
    /* this is not needed
    ImageConsumer t = target;
    if(t!=null) try {
    */
    try {
      for (int i = 0; i < signature.length; i++)
        if ((signature[i] & 0xFF) != underlyingInputStream.read())
          throw new PNGException("Chunk signature mismatch");

      InputStream is =
          new BufferedInputStream(new InflaterInputStream(inputStream, new Inflater()));

      getData();

      byte[] bPixels = null;
      int[] wPixels = null;
      int pixSize = width;
      int rowStride;
      int logDepth = 0;
      switch (bitDepth) {
        case 1:
          logDepth = 0;
          break;
        case 2:
          logDepth = 1;
          break;
        case 4:
          logDepth = 2;
          break;
        case 8:
          logDepth = 3;
          break;
        case 16:
          logDepth = 4;
          break;
        default:
          throw new PNGException("invalid depth");
      }
      if (interlaceMethod != 0) {
        pixSize *= height;
        rowStride = width;
      } else rowStride = 0;
      int combinedType = colorType | (bitDepth << 3);
      int bitMask = (1 << (bitDepth >= 8 ? 8 : bitDepth)) - 1;
      // Figure out the color model
      switch (colorType) {
        case COLOR | PALETTE:
        case COLOR | PALETTE | ALPHA:
          if (red_map == null) throw new PNGException("palette expected");
          if (alpha_map == null)
            cm = new IndexColorModel(bitDepth, red_map.length, red_map, green_map, blue_map);
          else
            cm =
                new IndexColorModel(
                    bitDepth, red_map.length, red_map, green_map, blue_map, alpha_map);
          bPixels = new byte[pixSize];
          break;
        case GRAY:
          {
            int llog = logDepth >= 4 ? 3 : logDepth;
            if ((cm = greyModels[llog]) == null) {
              int size = 1 << (1 << llog);

              byte ramp[] = new byte[size];
              for (int i = 0; i < size; i++) ramp[i] = (byte) (255 * i / (size - 1));

              if (transparentPixel == -1) {
                cm = new IndexColorModel(bitDepth, ramp.length, ramp, ramp, ramp);
              } else {
                cm =
                    new IndexColorModel(
                        bitDepth, ramp.length, ramp, ramp, ramp, (transparentPixel & 0xFF));
              }
              greyModels[llog] = cm;
            }
          }
          bPixels = new byte[pixSize];
          break;
        case COLOR:
        case COLOR | ALPHA:
        case GRAY | ALPHA:
          cm = ColorModel.getRGBdefault();
          wPixels = new int[pixSize];
          break;
        default:
          throw new PNGException("invalid color type");
      }
      /* this is going to be set in the pixel store
        t.setColorModel(cm);
      t.setHints(interlaceMethod !=0
                 ? ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES
                 : ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES |
                   ImageConsumer.SINGLEPASS | ImageConsumer.SINGLEFRAME);
                   */
      // code added to make it work with ImageDecoder architecture
      setDimensions(width, height);
      setColorModel(cm);
      int flags =
          (interlaceMethod != 0
              ? ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES
              : ImageConsumer.TOPDOWNLEFTRIGHT
                  | ImageConsumer.COMPLETESCANLINES
                  | ImageConsumer.SINGLEPASS
                  | ImageConsumer.SINGLEFRAME);
      setHints(flags);
      headerComplete();
      // end of adding

      int samplesPerPixel =
          ((colorType & PALETTE) != 0
              ? 1
              : ((colorType & COLOR) != 0 ? 3 : 1) + ((colorType & ALPHA) != 0 ? 1 : 0));
      int bitsPerPixel = samplesPerPixel * bitDepth;
      int bytesPerPixel = (bitsPerPixel + 7) >> 3;
      int pass, passLimit;
      if (interlaceMethod == 0) {
        pass = -1;
        passLimit = 0;
      } else {
        pass = 0;
        passLimit = 7;
      }
      // These loops are far from being tuned.  They're this way to make them easy to
      // debug.  Tuning comes later.
      /* code changed. target not needed here
      while(++pass<=passLimit && (t=target)!=null) {
      */
      while (++pass <= passLimit) {
        int row = startingRow[pass];
        int rowInc = rowIncrement[pass];
        int colInc = colIncrement[pass];
        int bWidth = blockWidth[pass];
        int bHeight = blockHeight[pass];
        int sCol = startingCol[pass];
        int rowPixelWidth = (width - sCol + (colInc - 1)) / colInc;
        int rowByteWidth = ((rowPixelWidth * bitsPerPixel) + 7) >> 3;
        if (rowByteWidth == 0) continue;
        int pixelBufferInc = interlaceMethod == 0 ? rowInc * width : 0;
        int rowOffset = rowStride * row;
        boolean firstRow = true;

        byte[] rowByteBuffer = new byte[rowByteWidth];
        byte[] prevRowByteBuffer = new byte[rowByteWidth];
        /* code changed. target not needed here
        while (row < height && (t=target)!=null) {
        */
        while (row < height) {
          int rowFilter = is.read();
          for (int rowFillPos = 0; rowFillPos < rowByteWidth; ) {
            int n = is.read(rowByteBuffer, rowFillPos, rowByteWidth - rowFillPos);
            if (n <= 0) throw new PNGException("missing data");
            rowFillPos += n;
          }
          filterRow(
              rowByteBuffer,
              firstRow ? null : prevRowByteBuffer,
              rowFilter,
              rowByteWidth,
              bytesPerPixel);
          int col = sCol;
          int spos = 0;
          int pixel = 0;
          while (col < width) {
            if (wPixels != null) {
              switch (combinedType) {
                case COLOR | ALPHA | (8 << 3):
                  wPixels[col + rowOffset] =
                      ((rowByteBuffer[spos] & 0xFF) << 16)
                          | ((rowByteBuffer[spos + 1] & 0xFF) << 8)
                          | ((rowByteBuffer[spos + 2] & 0xFF))
                          | ((rowByteBuffer[spos + 3] & 0xFF) << 24);
                  spos += 4;
                  break;
                case COLOR | ALPHA | (16 << 3):
                  wPixels[col + rowOffset] =
                      ((rowByteBuffer[spos] & 0xFF) << 16)
                          | ((rowByteBuffer[spos + 2] & 0xFF) << 8)
                          | ((rowByteBuffer[spos + 4] & 0xFF))
                          | ((rowByteBuffer[spos + 6] & 0xFF) << 24);
                  spos += 8;
                  break;
                case COLOR | (8 << 3):
                  pixel =
                      ((rowByteBuffer[spos] & 0xFF) << 16)
                          | ((rowByteBuffer[spos + 1] & 0xFF) << 8)
                          | ((rowByteBuffer[spos + 2] & 0xFF));
                  if (pixel != transparentPixel) {
                    pixel |= 0xff000000;
                  }
                  wPixels[col + rowOffset] = pixel;
                  spos += 3;
                  break;
                case COLOR | (16 << 3):
                  pixel =
                      ((rowByteBuffer[spos] & 0xFF) << 16)
                          | ((rowByteBuffer[spos + 2] & 0xFF) << 8)
                          | ((rowByteBuffer[spos + 4] & 0xFF));

                  boolean isTransparent = (transparentPixel_16 != null);
                  for (int i = 0; isTransparent && (i < 6); i++) {
                    isTransparent &=
                        (rowByteBuffer[spos + i] & 0xFF) == (transparentPixel_16[i] & 0xFF);
                  }
                  if (!isTransparent) {
                    pixel |= 0xff000000;
                  }
                  wPixels[col + rowOffset] = pixel;
                  spos += 6;
                  break;
                case GRAY | ALPHA | (8 << 3):
                  {
                    int tx = rowByteBuffer[spos] & 0xFF;
                    wPixels[col + rowOffset] =
                        (tx << 16) | (tx << 8) | tx | ((rowByteBuffer[spos + 1] & 0xFF) << 24);
                  }
                  spos += 2;
                  break;
                case GRAY | ALPHA | (16 << 3):
                  {
                    int tx = rowByteBuffer[spos] & 0xFF;
                    wPixels[col + rowOffset] =
                        (tx << 16) | (tx << 8) | tx | ((rowByteBuffer[spos + 2] & 0xFF) << 24);
                  }
                  spos += 4;
                  break;
                default:
                  throw new PNGException("illegal type/depth");
              }
            } else
              switch (bitDepth) {
                case 1:
                  bPixels[col + rowOffset] =
                      (byte) ((rowByteBuffer[spos >> 3] >> (7 - (spos & 7))) & 1);
                  spos++;
                  break;
                case 2:
                  bPixels[col + rowOffset] =
                      (byte) ((rowByteBuffer[spos >> 2] >> ((3 - (spos & 3)) * 2)) & 3);
                  spos++;
                  break;
                case 4:
                  bPixels[col + rowOffset] =
                      (byte) ((rowByteBuffer[spos >> 1] >> ((1 - (spos & 1)) * 4)) & 15);
                  spos++;
                  break;
                case 8:
                  bPixels[col + rowOffset] = rowByteBuffer[spos++];
                  break;
                case 16:
                  bPixels[col + rowOffset] = rowByteBuffer[spos];
                  spos += 2;
                  break;
                default:
                  throw new PNGException("illegal type/depth");
              }
            /*visit (row, col,
            min (bHeight, height - row),
            min (bWidth, width - col)); */
            col += colInc;
          }
          if (interlaceMethod == 0)
            if (wPixels != null) {
              /* code changed. target not needed here
              t.setPixels(0,row,width,1,cm,wPixels,0,width);
              */
              // code added to make it work with ImageDecoder arch
              sendPixels(0, row, width, 1, wPixels, 0, width);
              // end of adding
            } else {
              /* code changed. target not needed here
              t.setPixels(0,row,width,1,cm,bPixels,0,width);
              */
              // code added to make it work with ImageDecoder arch
              sendPixels(0, row, width, 1, bPixels, 0, width);
              // end of adding
            }
          row += rowInc;
          rowOffset += rowInc * rowStride;
          byte[] T = rowByteBuffer;
          rowByteBuffer = prevRowByteBuffer;
          prevRowByteBuffer = T;
          firstRow = false;
        }
        if (interlaceMethod != 0)
          if (wPixels != null) {
            /* code changed. target not needed here
            t.setPixels(0,0,width,height,cm,wPixels,0,width);
            */
            // code added to make it work with ImageDecoder arch
            sendPixels(0, 0, width, height, wPixels, 0, width);
            // end of adding
          } else {
            /* code changed. target not needed here
            t.setPixels(0,0,width,height,cm,bPixels,0,width);
            */
            // code added to make it work with ImageDecoder arch
            sendPixels(0, 0, width, height, bPixels, 0, width);
            // end of adding
          }
      }

      /* Here, the function "visit(row,column,height,width)" obtains the
      next transmitted pixel and paints a rectangle of the specified
      height and width, whose upper-left corner is at the specified row
      and column, using the color indicated by the pixel.  Note that row
      and column are measured from 0,0 at the upper left corner. */

      /* code not needed, don't deal with target
      if((t=target)!=null) {
        if(properties!=null) t.setProperties(properties);
          t.imageComplete(ImageConsumer.STATICIMAGEDONE);
          */

      imageComplete(ImageConsumer.STATICIMAGEDONE, true);

      /* code not needed }
      is.close();
      */
    } catch (IOException e) {
      if (!aborted) {
        /* code not needed
           if((t=target)!=null) {
           PNGEncoder.prChunk(e.toString(),inbuf,pos,limit-pos,true);
        */
        property("error", e);
        /* code not needed
           t.setProperties(properties);
           t.imageComplete(ImageConsumer.IMAGEERROR|ImageConsumer.STATICIMAGEDONE);
        */
        imageComplete(ImageConsumer.IMAGEERROR | ImageConsumer.STATICIMAGEDONE, true);
        throw e;
      }
    } finally {
      try {
        close();
      } catch (Throwable e) {
      }
      /* code not needed
      target = null;
      endTurn();
      */
    }
  }