org.apache.slide.urlEncoding=UTF-8

org.apache.slide.urlEncoding=WINDOWS-1252

         * Property specifying the encoding for URLs.

         * Property specifying if UTF-8 should be used to encode URLs.

         * <pre>

         * org.apache.slide.urlEncoding

         * </pre>

         */

        public static final String UseUtf = "org.apache.slide.useUtf8";

        /**

         * Property specifying the encoding for URLs when it's not UTF-8.

     * Returns the used URL encoding.

     * Returns true if UTF-8 should be used to encode urls.

     */

    public static boolean useUTF8() {

        return _useUtf8;

    }

    /**

     * Returns the used URL encoding when non UTF-8.

        // destinationUri = WebdavUtils.decodeURL(WebdavUtils.fixTomcatURL(destinationUri, "ISO-8859-1"));

        // destinationUri = WebdavUtils.normalizeURL(WebdavUtils.fixTomcatURL(destinationUri, "ISO-8859-1"));

        uri = WebdavUtils.decodeURL(uri);

        uri = WebdavUtils.normalizeURL(WebdavUtils.fixTomcatURL(uri));

                    resp.getWriter().write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");

                    resp.getWriter().write("<?xml version=\"1.0\" encoding=\""+Configuration.realUrlEncoding()+"\"?>");

 * $Header: /home/cvspublic/jakarta-slide/src/webdav/server/org/apache/slide/webdav/util/WebdavUtils.java,v 1.26 2004/09/08 04:14:31 ozeigermann Exp $

 * $Header: /home/cvspublic/jakarta-slide/src/webdav/server/org/apache/slide/webdav/util/WebdavUtils.java,v 1.25 2004/09/01 10:34:48 unico Exp $

 * $Revision: 1.26 $

 * $Revision: 1.25 $

 * $Date: 2004/09/08 04:14:31 $

 * $Date: 2004/09/01 10:34:48 $

    public static String URLDecode(String string, String enc) {

    /**

     * Constructs a new String based on bytes sequence contained

     * in the

     * Non-ASCII parts of the sequence will be decoded with UTF-8

     * if possible, or with the specified encoding.

     *

     * @param string A "String" returned by tomcat getPathInfo()

     * @param enc Encoding to use if non UTF-8

     * @return A properly encoded String object

     */

    public static String decodeString(String string, String enc)

        throws UnsupportedEncodingException {

        byte bytes[] = string.getBytes();

        StringBuffer sb = null;

        int len = bytes.length;

        int j = 0;

        int ix = 0;

        int sf = 0;

        int ox = 0;

        sb = new StringBuffer();

        boolean isUtf8 = true;

        byte utf8buffer[] = new byte[5];

        int shouldFollow = 0;

        // Get bytes without any decoding

        while(ix < len)  {

        byte bytes[] = string.getBytes("ISO-8859-1");

            byte b = bytes[ix++];

        for (int i = 0; i < bytes.length; i+=1) {

            if(b == 37) { // % character found, followed by hex digit

            byte b = bytes[i];

                b = (byte)((convertHexDigitToByte(bytes[ix++]) << 4) + convertHexDigitToByte(bytes[ix++]));

            int bb = (b >= 0) ? b : b+256;

                int i = 256+b;

//            System.out.print("0x"+Integer.toHexString(bb)+ " ");

                if (shouldFollow == 0) {

            utf8buffer[j++] = b;

                    if (i<256)

            boolean ok = false;

                        if (i>191)

            // First test if non-ascii

                            if (i>223)

            if (bb >= 128) {

                                if (i>239)

                // No ongoing UTF-8 decoding ?

                                    if (i>247)

                if (sf==0) {

                                        if (i>251)

                    // Now test if this can be a UTF-8 first byte

                                            isUtf8 = false;

                    if (bb >= 192 && i < 252) {

                                        else

                        ok = true;

                                            shouldFollow = 4;

                        // Determine UTF-8 size

                                    else

                        if (bb >= 224)

                                        shouldFollow = 3;

                            if (bb >= 240)

                                if (bb >= 248)

                                    sf = 4;

                                    shouldFollow = 2;

                                    sf = 3;

                                shouldFollow = 1;

                                sf = 2;

                            isUtf8 = false;

                            sf = 1;

                    else

                    }

                        shouldFollow = 0;

                } else if (bb >= 128 && bb < 192) {

                } else {

                    // This is a UTF-8 part

                    shouldFollow --;

                    sf--;

                    if (sf == 0) {

                        sb.append(new String(utf8buffer,0,j,"UTF-8"));

                        j = 0;

                    }

                    ok = true;

            // If there was an error during UTF-8 decoding, decode all remaining chars with default encoding

            bytes[ox++] = b;

            if (!ok) {

        }

                sb.append(new String(utf8buffer,0,j, enc));

        String res;

                j = 0;

        try {

                sf = 0;

            if(shouldFollow == 0 && isUtf8) {

                res = new String(bytes, 0, ox, "UTF-8");

            } else {

                res  = new String(bytes, 0, ox, enc);

        // Remaining chars

        return null;

        if (j > 0) {

            sb.append(new String(utf8buffer,0,j, enc));

        }

//        System.out.println();

//        System.out.println(sb);

        return sb.toString();

    public static String decodeURL(String path) {

    public static String normalizeURL(String path) {

        return decodeURL(path, Configuration.urlEncoding());

    }

    /**

     * Return a context-relative path, beginning with a "/", that represents

     * the canonical version of the specified path after ".." and "." elements

     * are resolved out.  If the specified path attempts to go outside the

     * boundaries of the current context (i.e. too many ".." path elements

     * are present), return <code>null</code> instead.

     *

     * @param path the path to be normalized

     **/

    public static String decodeURL(String path, String enc) {

        // Resolve encoded characters in the normalized path,

        String normalized = path;

        // which also handles encoded spaces so we can skip that later.

        // Placed at the beginning of the chain so that encoded

        // bad stuff(tm) can be caught by the later checks

        String normalized = URLDecode(path, enc);

        normalized = normalized.replace('?','_');

        return URLUtil.URLEncode(path, Configuration.urlEncoding());

        return URLUtil.URLEncode(path, Configuration.realUrlEncoding());

            result = req.getPathInfo();

            result = req.getRequestURI();

            result = result.substring(req.getContextPath().length()+ req.getServletPath().length());

        return normalizeURL(fixTomcatURL(result));  // the request URL is utf-8 encoded

        return decodeURL(fixTomcatURL(result, "UTF-8"));  // the request URL is utf-8 encoded

    public static String fixTomcatURL(String input, String fromEncoding) {

    public static String fixTomcatURL(String input) {

        return fixTomcatHeader(input, "UTF-8");

        if (input == null) return null;

        String result = null;

        try {

            //          printString(input.substring(27,input.length()));

            //          byte[] a = input.getBytes("UTF-8");

            result = encodeURL(new String(input.getBytes(fromEncoding), Configuration.urlEncoding()),

                               Configuration.urlEncoding());

            //          printString(result.substring(27,result.length()));

            //          byte[] b = result.getBytes(Configuration.urlEncoding());

            //          System.out.println("Length b " + b.length);

        } catch (Exception e) { e.printStackTrace(); }

        //      System.out.println("Length = " + input.length());

        //      System.out.println("Length = " + result.length());

        return result;

        // todo: toEncoding parameter not used anymore

            result = URLUtil.URLDecode(new String(header.getBytes("ISO-8859-1"), toEncoding),

            result = URLUtil.URLDecode(header.getBytes("ISO-8859-1"),"ISO-8859-1");

                                       toEncoding);

            result = decodeString(result,Configuration.urlEncoding());

            if (!Configuration.useUTF8()) {

                // Remove unsupported characters

                result = new String(result.getBytes(Configuration.urlEncoding()),Configuration.urlEncoding());

            }