Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Licensed to the Apache Software Foundation (ASF) under one or more
   *  contributor license agreements.  See the NOTICE file distributed with
   *  this work for additional information regarding copyright ownership.
   *  The ASF licenses this file to You under the Apache License, Version 2.0
   *  (the "License"); you may not use this file except in compliance with
   *  the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 package org.apache.tomcat.util.http;
 
 import static org.jboss.web.CoyoteMessages.MESSAGES;
 
 import java.util.Map;
 

Author(s):
Costin Manolache
 
 public final class Parameters {
 
     protected static final int MAX_COUNT = 
         Integer.valueOf(System.getProperty("org.apache.tomcat.util.http.Parameters.MAX_COUNT""512")).intValue();
 
     private final HashMap<String,ArrayList<String>> paramHashValues =
         new HashMap<String,ArrayList<String>>();
     private boolean didQueryParameters=false;
 
 
     UDecoder urlDec;
     MessageBytes decodedQuery=MessageBytes.newInstance();
 
     String encoding=null;
     String queryStringEncoding=null;
 
     private int limit = ;
     private int parameterCount = 0;

    
Is set to true if there were failures during parameter parsing.
 
     private boolean parseFailed = false;
 
     public Parameters() {
         // NO-OP
     }
 
     public void setQueryMessageBytes queryMB ) {
         this.=queryMB;
     }
 
     public void setLimit(int limit) {
         this. = limit;
     }
 
     public String getEncoding() {
         return ;
     }
 
     public void setEncodingString s ) {
         =s;
     }
 
     public void setQueryStringEncodingString s ) {
         =s;
     }
 
     public boolean isParseFailed() {
         return ;
     }
 
     public void setParseFailed(boolean parseFailed) {
         this. = parseFailed;
     }
 
     public void recycle() {
          = 0;
         .clear();
        =false;
        =null;
        .recycle();
         = false;
    }
    // -------------------- Data access --------------------
    // Access to the current name/values, no side effect ( processing ).
    // You must explicitely call handleQueryParameters and the post methods.
    // This is the original data representation ( hash of String->String[])
    public void addParameterValues(String nameString[] values) {
        if (name == null || values == null) {
            return;
        }
        for (int i = 0; i < values.lengthi++) {
            addParameter(namevalues[i]);
        }
    }
    public String[] getParameterValues(String name) {
        handleQueryParameters();
        // no "facade"
        ArrayList<Stringvalues = .get(name);
        if (values == null) {
            return null;
        }
        return values.toArray(new String[values.size()]);
    }
    public Enumeration<StringgetParameterNames() {
        handleQueryParameters();
        return Collections.enumeration(.keySet());
    }
    public String getParameter(String name ) {
        handleQueryParameters();
        ArrayList<Stringvalues = .get(name);
        if (values != null) {
            if(values.size() == 0) {
                return "";
            }
            return values.get(0);
        } else {
            return null;
        }
    }
    // -------------------- Processing --------------------
    
Process the query string into parameters
    public void handleQueryParameters() {
        if ) {
            return;
        }
        =true;
        if==null || .isNull() ) {
            return;
        }
        try {
            .duplicate );
        } catch (IOException e) {
            // Can't happen, as decodedQuery can't overflow
            e.printStackTrace();
        }
    }
    public void addParameterString keyString value )
            throws IllegalStateException {
        ifkey==null ) {
            return;
        }
         ++;
        if ( > -1 &&  > ) {
            // Processing this parameter will push us over the limit. ISE is
            // what Request.parseParts() uses for requests that are too big
             = true;
            throw .maxParametersFail();
        }
        ArrayList<Stringvalues = .get(key);
        if (values == null) {
            values = new ArrayList<String>(1);
            .put(keyvalues);
        }
        values.add(value);
    }
    public void setURLDecoderUDecoder u ) {
        =u;
    }
    // -------------------- Parameter parsing --------------------
    // we are called from a single thread - we can do it the hard way
    // if needed
    ByteChunk tmpName=new ByteChunk();
    private final ByteChunk origName=new ByteChunk();
    private final ByteChunk origValue=new ByteChunk();
    CharChunk tmpNameC=new CharChunk(1024);
    public static final String DEFAULT_ENCODING = "ISO-8859-1";
    private static final Charset DEFAULT_CHARSET =
        Charset.forName();
    public void processParametersbyte bytes[], int startint len ) {
        processParameters(bytesstartlen);
    }
    private void processParameters(byte bytes[], int startint lenString enc) {
        if (..isDebugEnabled()) {
            ..startProcessingParameter(new String(bytesstartlen));
        }
        int decodeFailCount = 0;
        int pos = start;
        int end = start + len;
        while(pos < end) {
            int nameStart = pos;
            int nameEnd = -1;
            int valueStart = -1;
            int valueEnd = -1;
            boolean parsingName = true;
            boolean decodeName = false;
            boolean decodeValue = false;
            boolean parameterComplete = false;
            do {
                switch(bytes[pos]) {
                    case '=':
                        if (parsingName) {
                            // Name finished. Value starts from next character
                            nameEnd = pos;
                            parsingName = false;
                            valueStart = ++pos;
                        } else {
                            // Equals character in value
                            pos++;
                        }
                        break;
                    case '&':
                        if (parsingName) {
                            // Name finished. No value.
                            nameEnd = pos;
                        } else {
                            // Value finished
                            valueEnd  = pos;
                        }
                        parameterComplete = true;
                        pos++;
                        break;
                    case '%':
                    case '+':
                        // Decoding required
                        if (parsingName) {
                            decodeName = true;
                        } else {
                            decodeValue = true;
                        }
                        pos ++;
                        break;
                    default:
                        pos ++;
                        break;
                }
            } while (!parameterComplete && pos < end);
            if (pos == end) {
                if (nameEnd == -1) {
                    nameEnd = pos;
                } else if (valueStart > -1 && valueEnd == -1){
                    valueEnd = pos;
                }
            }
            if (..isDebugEnabled() && valueStart == -1) {
                ..parameterMissingEqual(nameStartnameEndnew String(bytesnameStartnameEnd-nameStart));
            }
            if (nameEnd <= nameStart ) {
                if (valueStart == -1) {
                    // &&
                    if (..isDebugEnabled()) {
                        ..emptyParamterChunk();
                    }
                    // Do not flag as error
                    continue;
                }
                // &=foo&
                if (..isDebugEnabled()) {
                    String extract;
                    if (valueEnd >= nameStart) {
                        extract = new String(bytesnameStartvalueEnd
                                - nameStart);
                    } else {
                        extract = "";
                    }
                    ..parameterInvalid(nameStartvalueEndextract);
                }
                 = true;
                continue;
                // invalid chunk - it's better to ignore
            }
            .setBytes(bytesnameStartnameEnd - nameStart);
            if (valueStart >= 0) {
                .setBytes(bytesvalueStartvalueEnd - valueStart);
            } else {
                .setBytes(bytes, 0, 0);
            }
            // Take copies as if anything goes wrong originals will be
            // corrupted. This means original values can be logged.
            // For performance - only done for debug
            if (..isDebugEnabled()) {
                try {
                    .append(bytesnameStartnameEnd - nameStart);
                    if (valueStart >= 0) {
                        .append(bytesvalueStartvalueEnd - valueStart);
                    } else {
                        .append(bytes, 0, 0);
                    }
                } catch (IOException ioe) {
                    // Should never happen...
                     = true;
                    ..parametersCopyFailed();
                }
            }
            try {
                String name;
                String value;
                if (decodeName) {
                    urlDecode();
                }
                .setEncoding(enc);
                name = .toString();
                if (valueStart >= 0) {
                    if (decodeValue) {
                        urlDecode();
                    }
                    .setEncoding(enc);
                    value = .toString();
                } else {
                    value = "";
                }
                addParameter(namevalue);
            } catch (IOException e) {
                 = true;
                decodeFailCount++;
                if (..isDebugEnabled()) {
                }
            }
            .recycle();
            .recycle();
            // Only recycle copies if we used them
            if (..isDebugEnabled()) {
                .recycle();
                .recycle();
            }
        }
        if (decodeFailCount > 1 && ..isDebugEnabled()) {
            ..parametersDecodingFailures(decodeFailCount);
        }
        if () {
        }
    }
    private void urlDecode(ByteChunk bc)
        throws IOException {
        if==null ) {
            =new UDecoder();
        }
        .convert(bctrue);
    }
    public void processParametersMessageBytes dataString encoding ) {
        ifdata==null || data.isNull() || data.getLength() <= 0 ) {
            return;
        }
        ifdata.getType() != . ) {
            data.toBytes();
        }
        ByteChunk bc=data.getByteChunk();
        processParametersbc.getBytes(), bc.getOffset(),
                           bc.getLength(), encoding);
    }

    
Debug purpose
    public String paramsAsString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<StringArrayList<String>> e : .entrySet()) {
            sb.append(e.getKey()).append('=');
            ArrayList<Stringvalues = e.getValue();
            for (String value : values) {
                sb.append(value).append(',');
            }
            sb.append('\n');
        }
        return sb.toString();
    }
New to GrepCode? Check out our FAQ X