import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String encode(String item, short encFor) throws PageException  {
	
	PrintStream out = System.out;
	try {
		 System.setOut(new PrintStream(DevNullOutputStream.DEV_NULL_OUTPUT_STREAM));
		 Encoder encoder = ESAPI.encoder();
		 switch(encFor){
		 //case ENC_CSS:return encoder.encodeForBase64(item);
		 case ENC_CSS:return encoder.encodeForCSS(item);
		 case ENC_DN:return encoder.encodeForDN(item);
		 case ENC_HTML:return encoder.encodeForHTML(item);
		 case ENC_HTML_ATTR:return encoder.encodeForHTMLAttribute(item);
		 case ENC_JAVA_SCRIPT:return encoder.encodeForJavaScript(item);
		 case ENC_LDAP:return encoder.encodeForLDAP(item);
		 //case ENC_CSS:return encoder.encodeForOS(arg0, arg1)(item);
		 //case ENC_CSS:return encoder.encodeForSQL(arg0, arg1)CSS(item);
		 case ENC_URL:return encoder.encodeForURL(item);
		 case ENC_VB_SCRIPT:return encoder.encodeForVBScript(item);
		 case ENC_XML:return encoder.encodeForXML(item);
		 case ENC_XML_ATTR:return encoder.encodeForXMLAttribute(item);
		 case ENC_XPATH:return encoder.encodeForXPath(item);
		 }
		 throw new ApplicationException("invalid target encoding defintion");
	}
	catch(EncodingException ee){
		throw Caster.toPageException(ee);
	}
	finally {
		 System.setOut(out);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String decode(String item, short decFrom) throws PageException  {
	
	PrintStream out = System.out;
	try {
		 System.setOut(new PrintStream(DevNullOutputStream.DEV_NULL_OUTPUT_STREAM));
		 Encoder encoder = ESAPI.encoder();
		 switch(decFrom){
		 case DEC_URL:return encoder.decodeFromURL(item);
		 }
		 throw new ApplicationException("invalid target decoding defintion");
	}
	catch(EncodingException ee){
		throw Caster.toPageException(ee);
	}
	finally {
		 System.setOut(out);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String decode(String item, short decFrom) throws PageException  {
	
	PrintStream out = System.out;
	try {
		 System.setOut(new PrintStream(DevNullOutputStream.DEV_NULL_OUTPUT_STREAM));
		 Encoder encoder = ESAPI.encoder();
		 switch(decFrom){
		 case DEC_URL:return encoder.decodeFromURL(item);
		 //case DEC_BASE64:return encoder.decodeFromBase64(item);
		 case DEC_HTML:return encoder.decodeForHTML(item);
		 }
		 throw new ApplicationException("invalid target decoding defintion");
	}
	catch(EncodingException ee){
		throw Caster.toPageException(ee);
	}
	finally {
		 System.setOut(out);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * Encode tag's content for usage in a URL.
 * @param content The tag's content as a String
 * @param enc Encoder used to call
 * 	{@link Encoder#encodeForURL(String)}
 * @return content encoded for usage in a URL
 * @throws EncodingException if {@link Encoder#encodeForURL(String)} does.
 */
protected String encode(String content, Encoder enc) throws JspTagException
{
	try
	{
		return enc.encodeForURL(content);
	}
	catch(EncodingException e)
	{
		throw new JspTagException("Unable to encode to URL encoding", e);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public String encodeForURL(String input) throws EncodingException {
	if ( input == null ) {
		return null;
	}
	try {
		return URLEncoder.encode(input, ESAPI.securityConfiguration().getCharacterEncoding());
	} catch (UnsupportedEncodingException ex) {
		throw new EncodingException("Encoding failure", "Character encoding not supported", ex);
	} catch (Exception e) {
		throw new EncodingException("Encoding failure", "Problem URL encoding input", e);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public String decodeFromURL(String input) throws EncodingException {
	if ( input == null ) {
		return null;
	}
	String canonical = canonicalize(input);
	try {
		return URLDecoder.decode(canonical, ESAPI.securityConfiguration().getCharacterEncoding());
	} catch (UnsupportedEncodingException ex) {
		throw new EncodingException("Decoding failed", "Character encoding not supported", ex);
	} catch (Exception e) {
		throw new EncodingException("Decoding failed", "Problem URL decoding input", e);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String encode(String item, short encFor, boolean canonicalize) throws PageException  {
	if(StringUtil.isEmpty(item)) return item;
	
	PrintStream out = System.out;
	try {
		 
		
		System.setOut(new PrintStream(DevNullOutputStream.DEV_NULL_OUTPUT_STREAM));
		 Encoder encoder = ESAPI.encoder();
		 if(canonicalize)item=encoder.canonicalize(item, false);
		 
		 switch(encFor){
		 case ENC_CSS:return encoder.encodeForCSS(item);
		 case ENC_DN:return encoder.encodeForDN(item);
		 case ENC_HTML:return encoder.encodeForHTML(item);
		 case ENC_HTML_ATTR:return encoder.encodeForHTMLAttribute(item);
		 case ENC_JAVA_SCRIPT:return encoder.encodeForJavaScript(item);
		 case ENC_LDAP:return encoder.encodeForLDAP(item);
		 case ENC_URL:return encoder.encodeForURL(item);
		 case ENC_VB_SCRIPT:return encoder.encodeForVBScript(item);
		 case ENC_XML:return encoder.encodeForXML(item);
		 case ENC_XML_ATTR:return encoder.encodeForXMLAttribute(item);
		 case ENC_XPATH:return encoder.encodeForXPath(item);
		 }
		 throw new ApplicationException("invalid target encoding defintion");
	}
	catch(EncodingException ee){
		throw Caster.toPageException(ee);
	}
	finally {
		 System.setOut(out);
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
private void addNameValuePairToQueryString(StringBuilder queryString, String name, String value) {
    if (UtilValidate.isNotEmpty(value)) {
        if (queryString.length() > 1) {
            queryString.append("&");
        }

        try {
            queryString.append(StringUtil.defaultWebEncoder.encodeForURL(name));
            queryString.append("=");
            queryString.append(StringUtil.defaultWebEncoder.encodeForURL(value));
        } catch (EncodingException e) {
            Debug.logError(e, module);
        }
    }
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static Map<String, Object> resetMetric(DispatchContext dctx, Map<String, ?> context) {
    String name = (String) context.get("name");
    try {
        name = StringUtil.defaultWebEncoder.decodeFromURL(name);
    } catch (EncodingException e) {
        return ServiceUtil.returnError("Exception thrown while decoding metric name \"" + name + "\"");
    }
    Metrics metric = MetricsFactory.getMetric(name);
    if (metric != null) {
        metric.reset();
        return ServiceUtil.returnSuccess();

    }
    return ServiceUtil.returnError("Metric \"" + name + "\" not found.");
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String encodeUrlWithId(HttpServletRequest request,
		String page, String id) {
	try {
		return encodeUrl(request, page) + "?id="
				+ ESAPI.encoder().encodeForURL(id);
	} catch (EncodingException e) {
		return "???";
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String encodeUrlWithPath(HttpServletRequest request,
		String path) {
	try {
		return encodeUrl(request, "browse") + "?path="
				+ ESAPI.encoder().encodeForURL(path);
	} catch (EncodingException e) {
		return "???";
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public static String encodeUrlWithTag(HttpServletRequest request, String tag) {
	try {
		return encodeUrl(request, "tags") + "?tag="
				+ ESAPI.encoder().encodeForURL(tag);
	} catch (EncodingException e) {
		return "???";
	}
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/** {@inheritDoc} */
public String encodeForURL(String s) throws EncodingException {
    return Encode.forUri(s);
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/** {@inheritDoc} */
public String decodeFromURL(String s) throws EncodingException {
    return _referenceEncoder.decodeFromURL(s);
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
public void findMatchingLabels(String component, String fileName, String key, String locale) throws MalformedURLException, SAXException, ParserConfigurationException, IOException, EncodingException, GeneralException {
    if (UtilValidate.isEmpty(component) && UtilValidate.isEmpty(fileName) && UtilValidate.isEmpty(key) && UtilValidate.isEmpty(locale)) {
        // Important! Don't allow unparameterized queries - doing so will result in loading the entire project into memory
        return;
    }
    for (LabelFile fileInfo : filesFound.values()) {
        if (UtilValidate.isNotEmpty(component) && !component.equals(fileInfo.componentName)) {
            continue;
        }
        if (UtilValidate.isNotEmpty(fileName) && !fileName.equals(fileInfo.getFileName())) {
            continue;
        }
        if (Debug.infoOn()) {
            Debug.logInfo("Current file : " + fileInfo.getFileName(), module);
        }
        Document resourceDocument = UtilXml.readXmlDocument(fileInfo.file.toURI().toURL(), false);
        Element resourceElem = resourceDocument.getDocumentElement();
        String labelKeyComment = "";
        for (Node propertyNode : UtilXml.childNodeList(resourceElem.getFirstChild())) {
            if (propertyNode instanceof Element) {
                Element propertyElem = (Element) propertyNode;
                String labelKey = StringUtil.defaultWebEncoder.canonicalize(propertyElem.getAttribute("key"));
                String labelComment = "";
                for (Node valueNode : UtilXml.childNodeList(propertyElem.getFirstChild())) {
                    if (valueNode instanceof Element) {
                        Element valueElem = (Element) valueNode;
                        // Support old way of specifying xml:lang value.
                        // Old way: en_AU, new way: en-AU
                        String localeName = valueElem.getAttribute("xml:lang");
                        if( localeName.contains("_")) {
                            localeName = localeName.replace('_', '-');
                        }
                        String labelValue = StringUtil.defaultWebEncoder.canonicalize(UtilXml.nodeValue(valueElem.getFirstChild()));
                        LabelInfo label = labels.get(labelKey + keySeparator + fileInfo.getFileName());

                        if (UtilValidate.isEmpty(label)) {
                            label = new LabelInfo(labelKey, labelKeyComment, fileInfo.getFileName(), localeName, labelValue, labelComment);
                            labels.put(labelKey + keySeparator + fileInfo.getFileName(), label);
                        } else {
                            if (label.setLabelValue(localeName, labelValue, labelComment, false)) {
                                duplicatedLocalesLabelsList.add(label);
                            }
                        }
                        localesFound.add(localeName);
                        labelComment = "";
                    } else if (valueNode instanceof Comment) {
                        labelComment = labelComment + StringUtil.defaultWebEncoder.canonicalize(valueNode.getNodeValue());
                    }
                }
                labelKeyComment = "";
            } else if (propertyNode instanceof Comment) {
                labelKeyComment = labelKeyComment + StringUtil.defaultWebEncoder.canonicalize(propertyNode.getNodeValue());
            }
        }
    }
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * Encode for use in a URL. This method performs <a
 * href="http://en.wikipedia.org/wiki/Percent-encoding">URL encoding</a>
 * on the entire string.
 * 
 * @see <a href="http://en.wikipedia.org/wiki/Percent-encoding">URL encoding</a>
 * 
 * @param input 
 * 		the text to encode for use in a URL
 * 
 * @return input 
 * 		encoded for use in a URL
 * 
 * @throws EncodingException 
 * 		if encoding fails
 */
String encodeForURL(String input) throws EncodingException;
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * Decode from URL. Implementations should first canonicalize and
 * detect any double-encoding. If this check passes, then the data is decoded using URL
 * decoding.
 * 
 * @param input 
 * 		the text to decode from an encoded URL
 * 
 * @return 
 * 		the decoded URL value
 * 
 * @throws EncodingException 
 * 		if decoding fails
 */
String decodeFromURL(String input) throws EncodingException;
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * Encode string for use in a URL.
 * @param str The string to encode.
 * @return str encoded for use in a URL.
 * @see Encoder#encodeForURL(String)
 */
public static String encodeForURL(String str) throws EncodingException
{
	return ESAPI.encoder().encodeForURL(str);
}
 

import org.owasp.esapi.errors.EncodingException; //导入依赖的package包/类
/**
 * Encode string for URL context
 * 
 * @param obj
 * @return
 * @throws EncodingException
 */
public static String url(Object obj) throws EncodingException {
	return encoder.encodeForURL(toStr(obj));
}