コード例 #1
0
ファイル: InputBuffer.java プロジェクト: dorisxt/tomcat7.0
  /** Recycle the output buffer. */
  public void recycle() {

    state = INITIAL_STATE;

    // If usage of mark made the buffer too big, reallocate it
    if (cb.getChars().length > size) {
      cb = new CharChunk(size);
      cb.setLimit(size);
      cb.setOptimizedWrite(false);
      cb.setCharInputChannel(this);
      cb.setCharOutputChannel(this);
    } else {
      cb.recycle();
    }
    markPos = -1;
    bb.recycle();
    closed = false;

    if (conv != null) {
      conv.recycle();
    }

    gotEnc = false;
    enc = null;
  }
コード例 #2
0
 protected Charset getDigestCharset() throws UnsupportedEncodingException {
   if (digestEncoding == null) {
     return Charset.defaultCharset();
   } else {
     return B2CConverter.getCharset(getDigestEncoding());
   }
 }
コード例 #3
0
ファイル: CoyoteAdapter.java プロジェクト: xiaobao2110/tomcat
  /** Character conversion of the URI. */
  protected void convertURI(MessageBytes uri, Request request) throws Exception {

    ByteChunk bc = uri.getByteChunk();
    int length = bc.getLength();
    CharChunk cc = uri.getCharChunk();
    cc.allocate(length, -1);

    String enc = connector.getURIEncoding();
    if (enc != null) {
      B2CConverter conv = request.getURIConverter();
      try {
        if (conv == null) {
          conv = new B2CConverter(enc, true);
          request.setURIConverter(conv);
        } else {
          conv.recycle();
        }
      } catch (IOException e) {
        log.error("Invalid URI encoding; using HTTP default");
        connector.setURIEncoding(null);
      }
      if (conv != null) {
        try {
          conv.convert(bc, cc, true);
          uri.setChars(cc.getBuffer(), cc.getStart(), cc.getLength());
          return;
        } catch (IOException ioe) {
          // Should never happen as B2CConverter should replace
          // problematic characters
          request.getResponse().sendError(HttpServletResponse.SC_BAD_REQUEST);
        }
      }
    }

    // Default encoding: fast conversion for ISO-8859-1
    byte[] bbuf = bc.getBuffer();
    char[] cbuf = cc.getBuffer();
    int start = bc.getStart();
    for (int i = 0; i < length; i++) {
      cbuf[i] = (char) (bbuf[i + start] & 0xff);
    }
    uri.setChars(cbuf, 0, length);
  }
コード例 #4
0
ファイル: Parameters.java プロジェクト: anoopgecbh/Tomcat-4
 private Charset getCharset(String encoding) {
   if (encoding == null) {
     return DEFAULT_CHARSET;
   }
   try {
     return B2CConverter.getCharset(encoding);
   } catch (UnsupportedEncodingException e) {
     return DEFAULT_CHARSET;
   }
 }
コード例 #5
0
  /*
   * Convert the textual message to bytes and then output it.
   */
  private void doWriteText(CharBuffer buffer, boolean finalFragment) throws IOException {
    CharsetEncoder encoder = B2CConverter.getUtf8().newEncoder();
    do {
      CoderResult cr = encoder.encode(buffer, bb, true);
      if (cr.isError()) {
        cr.throwException();
      }
      bb.flip();
      if (buffer.hasRemaining()) {
        doWriteBytes(bb, false);
      } else {
        doWriteBytes(bb, finalFragment);
      }
    } while (buffer.hasRemaining());

    // Reset - bb will be cleared in doWriteBytes()
    cb.clear();
  }
コード例 #6
0
ファイル: InputBuffer.java プロジェクト: dorisxt/tomcat7.0
  @Override
  public int realReadChars(char cbuf[], int off, int len) throws IOException {

    if (!gotEnc) {
      setConverter();
    }

    boolean eof = false;

    if (bb.getLength() <= 0) {
      int nRead = realReadBytes(bb.getBytes(), 0, bb.getBytes().length);
      if (nRead < 0) {
        eof = true;
      }
    }

    if (markPos == -1) {
      cb.setOffset(0);
      cb.setEnd(0);
    } else {
      // Make sure there's enough space in the worst case
      cb.makeSpace(bb.getLength());
      if ((cb.getBuffer().length - cb.getEnd()) == 0) {
        // We went over the limit
        cb.setOffset(0);
        cb.setEnd(0);
        markPos = -1;
      }
    }

    state = CHAR_STATE;
    conv.convert(bb, cb, eof);

    if (cb.getLength() == 0 && eof) {
      return -1;
    } else {
      return cb.getLength();
    }
  }
コード例 #7
0
ファイル: CoyoteAdapter.java プロジェクト: xiaobao2110/tomcat
  /**
   * Extract the path parameters from the request. This assumes parameters are of the form
   * /path;name=value;name2=value2/ etc. Currently only really interested in the session ID that
   * will be in this form. Other parameters can safely be ignored.
   *
   * @param req
   * @param request
   */
  protected void parsePathParameters(org.apache.coyote.Request req, Request request) {

    // Process in bytes (this is default format so this is normally a NO-OP
    req.decodedURI().toBytes();

    ByteChunk uriBC = req.decodedURI().getByteChunk();
    int semicolon = uriBC.indexOf(';', 0);

    // What encoding to use? Some platforms, eg z/os, use a default
    // encoding that doesn't give the expected result so be explicit
    String enc = connector.getURIEncoding();
    if (enc == null) {
      enc = "ISO-8859-1";
    }
    Charset charset = null;
    try {
      charset = B2CConverter.getCharset(enc);
    } catch (UnsupportedEncodingException e1) {
      log.warn(sm.getString("coyoteAdapter.parsePathParam", enc));
    }

    if (log.isDebugEnabled()) {
      log.debug(sm.getString("coyoteAdapter.debug", "uriBC", uriBC.toString()));
      log.debug(sm.getString("coyoteAdapter.debug", "semicolon", String.valueOf(semicolon)));
      log.debug(sm.getString("coyoteAdapter.debug", "enc", enc));
    }

    while (semicolon > -1) {
      // Parse path param, and extract it from the decoded request URI
      int start = uriBC.getStart();
      int end = uriBC.getEnd();

      int pathParamStart = semicolon + 1;
      int pathParamEnd =
          ByteChunk.findBytes(
              uriBC.getBuffer(), start + pathParamStart, end, new byte[] {';', '/'});

      String pv = null;

      if (pathParamEnd >= 0) {
        if (charset != null) {
          pv =
              new String(
                  uriBC.getBuffer(),
                  start + pathParamStart,
                  pathParamEnd - pathParamStart,
                  charset);
        }
        // Extract path param from decoded request URI
        byte[] buf = uriBC.getBuffer();
        for (int i = 0; i < end - start - pathParamEnd; i++) {
          buf[start + semicolon + i] = buf[start + i + pathParamEnd];
        }
        uriBC.setBytes(buf, start, end - start - pathParamEnd + semicolon);
      } else {
        if (charset != null) {
          pv =
              new String(
                  uriBC.getBuffer(),
                  start + pathParamStart,
                  (end - start) - pathParamStart,
                  charset);
        }
        uriBC.setEnd(start + semicolon);
      }

      if (log.isDebugEnabled()) {
        log.debug(
            sm.getString("coyoteAdapter.debug", "pathParamStart", String.valueOf(pathParamStart)));
        log.debug(
            sm.getString("coyoteAdapter.debug", "pathParamEnd", String.valueOf(pathParamEnd)));
        log.debug(sm.getString("coyoteAdapter.debug", "pv", pv));
      }

      if (pv != null) {
        int equals = pv.indexOf('=');
        if (equals > -1) {
          String name = pv.substring(0, equals);
          String value = pv.substring(equals + 1);
          request.addPathParameter(name, value);
          if (log.isDebugEnabled()) {
            log.debug(sm.getString("coyoteAdapter.debug", "equals", String.valueOf(equals)));
            log.debug(sm.getString("coyoteAdapter.debug", "name", name));
            log.debug(sm.getString("coyoteAdapter.debug", "value", value));
          }
        }
      }

      semicolon = uriBC.indexOf(';', semicolon);
    }
  }