http/base/src/main/java/org/apache/felix/http/base/internal/util/UriUtils.java

/*
 * 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.felix.http.base.internal.util;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;

/**
 * Some convenience methods for handling URI(-parts).
 */
public abstract class UriUtils
{
    private static final String SLASH_STR = "/";
    private static final char DOT = '.';
    private static final char SLASH = '/';

    /**
     * Concatenates two paths keeping their respective path-parts into consideration.
     *
     * @param path1 the first part of the path, can be <code>null</code>;
     * @param path2 the second part of the path, can be <code>null</code>.
     * @return the concatenated path, can be <code>null</code> in case both given arguments were <code>null</code>.
     */
    public static String concat(String path1, String path2)
    {
        // Handle special cases...
        if (path1 == null && path2 == null)
        {
            return null;
        }
        if (path1 == null)
        {
            path1 = "";
        }
        if (path2 == null)
        {
            path2 = "";
        }
        if (isEmpty(path1) && isEmpty(path2))
        {
            return "";
        }

        StringBuilder sb = new StringBuilder();

        int idx = path1.indexOf('?');
        if (idx == 0)
        {
            // path1 only consists of a query, append it to the second path...
            return path2.concat(path1);
        }
        else if (idx > 0)
        {
            // path1 contains of a path + query, append the path first...
            sb.append(path1.substring(0, idx));
        }
        else
        {
            // Plain paths...
            sb.append(path1);
            // need a slash?
        }

        if (endsWith(sb, SLASH_STR))
        {
            if (path2.startsWith(SLASH_STR))
            {
                sb.append(path2.substring(1));
            }
            else
            {
                sb.append(path2);
            }
        }
        else
        {
            if (path2.startsWith(SLASH_STR))
            {
                sb.append(path2);
            }
            else if (sb.length() > 0 && !isEmpty(path2))
            {
                sb.append(SLASH_STR).append(path2);
            }
            else
            {
                sb.append(path2);
            }
        }

        if (idx > 0)
        {
            // Add the query of path1...
            sb.append(path1.substring(idx, path1.length()));
        }

        return sb.toString();
    }

    /**
     * Decodes a given URL-encoded path assuming it is UTF-8 encoded.
     *
     * @param path the URL-encoded path, can be <code>null</code>.
     * @return the decoded path, can be <code>null</code> only if the given path was <code>null</code>.
     */
    public static String decodePath(String path)
    {
        return decodePath(path, "UTF-8");
    }

    /**
     * Decodes a given URL-encoded path using a given character encoding.
     *
     * @param path the URL-encoded path, can be <code>null</code>;
     * @param encoding the character encoding to use, cannot be <code>null</code>.
     * @return the decoded path, can be <code>null</code> only if the given path was <code>null</code>.
     */
    private static String decodePath(String path, String encoding)
    {
        // Special cases...
        if (path == null)
        {
            return null;
        }

        CharsetDecoder decoder = Charset.forName(encoding).newDecoder();
        decoder.onMalformedInput(CodingErrorAction.REPORT);
        decoder.onUnmappableCharacter(CodingErrorAction.REPORT);

        int len = path.length();
        ByteBuffer buf = ByteBuffer.allocate(len);
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < len; i++)
        {
            char ch = path.charAt(i);
            if (ch == '%' && (i + 2 < len))
            {
                // URL-encoded char...
                buf.put((byte) ((16 * hexVal(path, ++i)) + hexVal(path, ++i)));
            }
            else
            {
                if (buf.position() > 0)
                {
                    // flush encoded chars first...
                    sb.append(decode(buf, decoder));
                    buf.clear();
                }

                sb.append(ch);
            }
        }

        // flush trailing encoded characters...
        if (buf.position() > 0)
        {
            sb.append(decode(buf, decoder));
            buf.clear();
        }

        return sb.toString();
    }

    /**
     * Removes all superfluous dot-segments using the algorithm described in RFC-3986 section 5.2.4.
     *
     * @param path the path to remove all dot-segments from, can be <code>null</code>.
     * @return the cleaned path, can be <code>null</code> only if the given path was <code>null</code>.
     */
    public static String removeDotSegments(String path)
    {
        // Handle special cases...
        if (path == null)
        {
            return null;
        }
        if (isEmpty(path))
        {
            return "";
        }

        StringBuilder scratch = new StringBuilder(path);
        StringBuilder sb = new StringBuilder();
        char l, la = 0, laa = 0, laaa = 0;

        while (scratch.length() > 0)
        {
            l = la(scratch, 0);
            la = la(scratch, 1);
            laa = la(scratch, 2);

            if (l == DOT)
            {
                if (la == 0)
                {
                    // (D) found '.' at the end of the URL
                    break;
                }
                else if (la == DOT && laa == SLASH)
                {
                    // (A) found '../', remove it from the input...
                    scratch.delete(0, 3);
                    continue;
                }
                else if (la == DOT && laa == 0)
                {
                    // (D) found '..' at the end of the URL
                    break;
                }
                else if (la == SLASH)
                {
                    // (A) found './', remove it from the input...
                    scratch.delete(0, 2);
                    continue;
                }
            }
            else if (l == SLASH && la == DOT)
            {
                if (laa == SLASH)
                {
                    // (B) found '/./', remove the leading '/.'...
                    scratch.delete(0, 2);
                    continue;
                }
                else if (laa == 0)
                {
                    // (B) found '/.' as last part of the URL
                    sb.append(SLASH);
                    // we're done...
                    break;
                }
                else if (laa == DOT)
                {
                    laaa = la(scratch, 3);
                    if (laaa == SLASH)
                    {
                        // (C) found '/../', remove the '/..' part from the input...
                        scratch.delete(0, 3);

                        // go back one segment in the output, including the last '/'...
                        sb.setLength(lb(sb, 0));
                        continue;
                    }
                    else if (laaa == 0)
                    {
                        // (C) found '/..' as last part of the URL, go back one segment in the output, excluding the last '/'...
                        sb.setLength(lb(sb, -1));
                        // we're done...
                        break;
                    }
                }
            }

            // (E) Copy everything up to (but not including) the next '/'...
            do
            {
                sb.append(l);
                scratch.delete(0, 1);
                l = la(scratch, 0);
            }
            while (l != SLASH && l != 0);
        }

        return sb.toString();
    }

    private static char la(CharSequence sb, int idx)
    {
        if (sb.length() > idx)
        {
            return sb.charAt(idx);
        }
        return 0;
    }

    private static int lb(CharSequence sb, int offset)
    {
        int pos = sb.length() - 1 - offset;
        while (pos > 0 && sb.charAt(pos + offset) != SLASH)
        {
            pos--;
        }
        return pos;
    }

    private static String decode(ByteBuffer bb, CharsetDecoder decoder)
    {
        CharBuffer cb = CharBuffer.allocate(128);

        CoderResult result = decoder.decode((ByteBuffer) bb.flip(), cb, true /* endOfInput */);
        if (result.isError())
        {
            throw new IllegalArgumentException("Malformed UTF-8!");
        }

        return ((CharBuffer) cb.flip()).toString();
    }

    private static boolean endsWith(CharSequence seq, String part)
    {
        int len = part.length();
        if (seq.length() < len)
        {
            return false;
        }
        for (int i = 0; i < len; i++)
        {
            if (seq.charAt(seq.length() - (i + 1)) != part.charAt(i))
            {
                return false;
            }
        }
        return true;
    }

    private static int hexVal(CharSequence seq, int idx)
    {
        char ch = seq.charAt(idx);
        if (ch >= '0' && ch <= '9')
        {
            return ch - '0';
        }
        else if (ch >= 'a' && ch <= 'f')
        {
            return 10 + (ch - 'a');
        }
        else if (ch >= 'A' && ch <= 'F')
        {
            return 10 + (ch - 'A');
        }
        throw new IllegalArgumentException("Invalid hex digit: " + ch);
    }

    private static boolean isEmpty(String value)
    {
        return value == null || "".equals(value.trim());
    }

    /**
     * Creates a new {@link UriUtils} instance.
     */
    private UriUtils()
    {
        // Nop
    }
}