Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  javax.jcr.Binary
 *  javax.jcr.RepositoryException
 *  javax.servlet.http.HttpServletRequest
 *  org.apache.commons.io.IOUtils
 *  org.apache.http.Header
 *  org.apache.http.HttpEntity
 *  org.apache.http.HttpHost
 *  org.apache.http.NameValuePair
 *  org.apache.http.StatusLine
 *  org.apache.http.auth.AuthScheme
 *  org.apache.http.auth.AuthScope
 *  org.apache.http.auth.Credentials
 *  org.apache.http.client.AuthCache
 *  org.apache.http.client.CredentialsProvider
 *  org.apache.http.client.config.RequestConfig
 *  org.apache.http.client.config.RequestConfig$Builder
 *  org.apache.http.client.methods.CloseableHttpResponse
 *  org.apache.http.client.methods.HttpGet
 *  org.apache.http.client.methods.HttpPost
 *  org.apache.http.client.methods.HttpUriRequest
 *  org.apache.http.client.protocol.HttpClientContext
 *  org.apache.http.client.utils.URIBuilder
 *  org.apache.http.entity.ContentType
 *  org.apache.http.entity.mime.MultipartEntityBuilder
 *  org.apache.http.impl.auth.BasicScheme
 *  org.apache.http.impl.client.BasicAuthCache
 *  org.apache.http.impl.client.BasicCredentialsProvider
 *  org.apache.http.impl.client.CloseableHttpClient
 *  org.apache.http.message.BasicHeader
 *  org.apache.http.message.BasicNameValuePair
 *  org.apache.http.protocol.HttpContext
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.crx.packaging.impl.proxy;

import com.day.crx.packaging.Proxy;
import com.day.crx.packaging.ProxyTracker;
import com.day.crx.packaging.TrackingInputStream;
import com.day.crx.packaging.impl.proxy.AttributeList;
import com.day.crx.packaging.impl.proxy.DocumentHandler;
import com.day.crx.packaging.impl.proxy.HtmlParser;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.jcr.Binary;
import javax.jcr.RepositoryException;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.io.IOUtils;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.NameValuePair;
import org.apache.http.StatusLine;
import org.apache.http.auth.AuthScheme;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.Credentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ProxyImpl
implements DocumentHandler,
Proxy {
    private static final Logger log = LoggerFactory.getLogger(ProxyImpl.class);
    private static Pattern URL_PATTERN = Pattern.compile("url\\(\\s*(['\"]?)([^'\")]*)(['\"]?\\s*)\\)");
    private final String rewritePath;
    private final String spoolPath;
    private URI targetURL;
    private Writer writer;
    private boolean ignoreTypeAttribute;
    private List<NameValuePair> extraParams = new LinkedList<NameValuePair>();
    private MultipartEntityBuilder mpBuilder = null;
    private List<Header> extraHeaders = new LinkedList<Header>();
    private final CloseableHttpClient httpClient;
    private final HttpHost targetHost;
    private CloseableHttpResponse response;
    private String contentType;
    private String lastModified;
    private Credentials credentials;
    private ProxyTracker tracker;
    private String contextPath = "";
    private String idString = null;
    private boolean followRedirects = false;

    public ProxyImpl(CloseableHttpClient httpClient, HttpHost targetHost, String rewritePath, String spoolPath) {
        this.httpClient = httpClient;
        this.targetHost = targetHost;
        this.rewritePath = rewritePath;
        this.spoolPath = spoolPath;
    }

    @Override
    public ProxyTracker getTracker() {
        return this.tracker;
    }

    @Override
    public void setFollowRedirects(boolean followRedirects) {
        this.followRedirects = followRedirects;
    }

    @Override
    public void setTracker(ProxyTracker tracker) {
        this.tracker = tracker;
    }

    @Override
    public void setIdString(String id) {
        this.idString = id;
    }

    @Override
    public void setContextPath(String path) {
        if (path.length() > 0 && path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }
        this.contextPath = path;
    }

    @Override
    public void addExtraParameter(String name, String value) {
        this.extraParams.add((NameValuePair)new BasicNameValuePair(name, value));
    }

    @Override
    public void addExtraHeader(String name, String value) {
        this.extraHeaders.add((Header)new BasicHeader(name, value));
    }

    @Override
    public void addExtraParameters(HttpServletRequest request) {
        Enumeration e = request.getParameterNames();
        while (e.hasMoreElements()) {
            String name = e.nextElement().toString();
            for (String p : request.getParameterValues(name)) {
                this.extraParams.add((NameValuePair)new BasicNameValuePair(name, p));
            }
        }
    }

    @Override
    public void addExtraFile(String name, File file) throws FileNotFoundException {
        if (this.mpBuilder == null) {
            this.mpBuilder = MultipartEntityBuilder.create();
        }
        this.mpBuilder.addBinaryBody(name, file);
    }

    @Override
    public void addExtraFile(String name, File file, String fileName) throws FileNotFoundException {
        if (this.mpBuilder == null) {
            this.mpBuilder = MultipartEntityBuilder.create();
        }
        this.mpBuilder.addBinaryBody(name, file, ContentType.APPLICATION_OCTET_STREAM, fileName);
    }

    @Override
    public void addExtraFile(String name, Binary data, String filename) throws FileNotFoundException {
        if (this.mpBuilder == null) {
            this.mpBuilder = MultipartEntityBuilder.create();
        }
        this.mpBuilder.addBinaryBody(name, (InputStream)new BinaryInputStream(data), ContentType.APPLICATION_OCTET_STREAM, filename);
    }

    @Override
    public boolean isIgnoreTypeAttribute() {
        return this.ignoreTypeAttribute;
    }

    @Override
    public void setIgnoreTypeAttribute(boolean ignoreTypeAttribute) {
        this.ignoreTypeAttribute = ignoreTypeAttribute;
    }

    @Override
    public void setWriter(PrintWriter writer) {
        this.writer = writer;
    }

    @Override
    public Credentials getCredentials() {
        return this.credentials;
    }

    @Override
    public void setCredentials(Credentials credentials) {
        this.credentials = credentials;
    }

    @Override
    public void onStart() throws IOException {
    }

    @Override
    public void onStartElement(String name, AttributeList attList, char[] ch, int off, int len, boolean endSlash) throws IOException {
        String suffix = null;
        String upperName = name.toUpperCase();
        if ("A".equals(upperName)) {
            boolean spool = !this.ignoreTypeAttribute && attList.containsAttribute("type");
            this.rewriteRef(attList, "HREF", spool);
        } else if ("AREA".equals(upperName)) {
            this.rewriteRef(attList, "HREF", false);
        } else if ("FORM".equals(upperName)) {
            suffix = this.rewriteForm(attList);
        } else if ("FRAME".equals(upperName)) {
            this.rewriteRef(attList, "SRC", true);
        } else if ("IFRAME".equals(upperName)) {
            this.rewriteRef(attList, "SRC", true);
        } else if ("IMG".equals(upperName)) {
            this.rewriteRef(attList, "SRC", true);
        } else if ("INPUT".equals(upperName)) {
            this.rewriteRef(attList, "SRC", true);
        } else if ("LINK".equals(upperName)) {
            this.rewriteRef(attList, "HREF", true);
        } else if ("SCRIPT".equals(upperName)) {
            this.rewriteRef(attList, "SRC", true);
        } else if ("TABLE".equals(upperName)) {
            this.rewriteRef(attList, "BACKGROUND", true);
        } else if ("TD".equals(upperName)) {
            this.rewriteRef(attList, "BACKGROUND", true);
        } else if ("TR".equals(upperName)) {
            this.rewriteRef(attList, "BACKGROUND", true);
        }
        if (attList.isModified()) {
            this.writer.write(this.serialize(name, attList, endSlash));
        } else {
            this.writer.write(ch, off, len);
        }
        if (suffix != null) {
            this.writer.write(suffix);
        }
    }

    private String serialize(String name, AttributeList attList, boolean endSlash) {
        StringBuffer buffer = new StringBuffer(256);
        buffer.append("<");
        buffer.append(name);
        Iterator<String> attNames = attList.attributeNames();
        while (attNames.hasNext()) {
            String attName = attNames.next();
            String attValue = attList.getQuotedValue(attName);
            buffer.append(" ");
            buffer.append(attName);
            if (attValue == null) continue;
            buffer.append('=');
            buffer.append(attValue);
        }
        if (endSlash) {
            buffer.append(" /");
        }
        buffer.append(">");
        return buffer.toString();
    }

    @Override
    public void characters(char[] ch, int off, int len) throws IOException {
        this.writer.write(ch, off, len);
    }

    public void characters(String c) throws IOException {
        this.writer.write(c);
    }

    @Override
    public void onEndElement(String name, char[] ch, int off, int len) {
        try {
            this.writer.write(ch, off, len);
        }
        catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    @Override
    public void onEnd() throws IOException {
        this.writer.flush();
    }

    private String rewriteForm(AttributeList attList) {
        String action = attList.getValue("ACTION");
        if (action != null && action.length() > 0) {
            String method = attList.getValue("METHOD");
            action = this.rewriteURL(action, "POST".equalsIgnoreCase(method));
            attList.setValue("ACTION", action);
        }
        return null;
    }

    private void rewriteRef(AttributeList attList, String attName, boolean spool) {
        String ref = attList.getValue(attName);
        if (ref != null) {
            attList.setValue(attName, this.rewriteURL(ref, spool));
        }
    }

    @Override
    public String rewriteURL(String url, boolean spool) {
        if (url.startsWith("#")) {
            return url;
        }
        int firstSlash = url.indexOf(47);
        int firstColon = url.indexOf(58);
        if (firstColon >= 0 && (firstSlash < 0 || firstColon < firstSlash)) {
            return url;
        }
        if (firstSlash != 0) {
            url = this.targetURL.resolve(url).getPath();
        }
        StringBuilder newValue = new StringBuilder(this.contextPath);
        if (spool) {
            newValue.append(this.spoolPath);
        } else {
            newValue.append(this.rewritePath);
        }
        newValue.append(url);
        return newValue.toString();
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void rewriteHtml(InputStream in) throws IOException {
        String encoding = "8859_1";
        int charsetIndex = this.contentType.indexOf("charset=");
        if (charsetIndex != -1) {
            encoding = this.contentType.substring(charsetIndex + "charset=".length()).trim();
        }
        HashSet<String> inclusionSet = new HashSet<String>();
        inclusionSet.add("A");
        inclusionSet.add("AREA");
        inclusionSet.add("FORM");
        inclusionSet.add("FRAME");
        inclusionSet.add("IFRAME");
        inclusionSet.add("IMG");
        inclusionSet.add("INPUT");
        inclusionSet.add("LINK");
        inclusionSet.add("SCRIPT");
        inclusionSet.add("TABLE");
        inclusionSet.add("TD");
        inclusionSet.add("TR");
        inclusionSet.add("NOREWRITE");
        HtmlParser parser = new HtmlParser();
        parser.setTagInclusionSet(inclusionSet);
        parser.setDocumentHandler(this);
        BufferedReader reader = null;
        try {
            int len;
            reader = new BufferedReader(new InputStreamReader(in, encoding));
            char[] buf = new char[2048];
            while ((len = reader.read(buf)) != -1) {
                parser.update(buf, 0, len);
            }
            parser.finished();
        }
        finally {
            IOUtils.closeQuietly((Reader)reader);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public void spoolCss(Writer out) throws IOException {
        String encoding = "8859_1";
        int charsetIndex = this.contentType.indexOf("charset=");
        if (charsetIndex != -1) {
            encoding = this.contentType.substring(charsetIndex + "charset=".length()).trim();
        }
        long start = System.currentTimeMillis();
        String css = "";
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(this.response.getEntity().getContent(), encoding));
            css = IOUtils.toString((Reader)reader);
        }
        finally {
            IOUtils.closeQuietly((Reader)reader);
        }
        long end = System.currentTimeMillis();
        log.debug("read css in {}ms {} bytes", (Object)(end - start), (Object)css.length());
        Matcher m = URL_PATTERN.matcher(css);
        StringBuffer result = new StringBuffer();
        while (m.find()) {
            String url = m.group(2);
            if (url.startsWith("absolute:")) {
                url = url.substring(9);
            } else if (!url.endsWith(".htc") && !url.startsWith("//")) {
                url = this.rewriteURL(url, true);
            }
            m.appendReplacement(result, "url($1" + url + "$3)");
        }
        m.appendTail(result);
        out.write(result.toString());
        out.flush();
    }

    private URI prepare(String path) throws IOException, URISyntaxException {
        if (this.response != null) {
            throw new IllegalStateException("already connected");
        }
        if (!path.startsWith("/")) {
            throw new IllegalArgumentException("Invalid path " + path);
        }
        try {
            this.targetURL = new URI(path);
        }
        catch (URISyntaxException e) {
            throw new IOException(e);
        }
        LinkedList<NameValuePair> ps = new LinkedList<NameValuePair>(this.extraParams);
        if (this.idString != null) {
            ps.add((NameValuePair)new BasicNameValuePair("daypsid", this.idString));
        }
        if (this.credentials != null && path.indexOf("sling:authRequestLogin") < 0) {
            ps.add((NameValuePair)new BasicNameValuePair("sling:authRequestLogin", "1"));
        }
        URIBuilder uri = new URIBuilder((Object)this.targetHost + path);
        if (!ps.isEmpty()) {
            uri.addParameters(ps);
        }
        return uri.build();
    }

    private int postProcessResponse() {
        Header hdr = this.response.getFirstHeader("Content-Type");
        this.contentType = hdr == null ? "text/plain" : hdr.getValue();
        Header h = this.response.getFirstHeader("Last-Modified");
        this.lastModified = h == null ? null : h.getValue();
        return this.response.getStatusLine().getStatusCode();
    }

    @Override
    public int doGet(String path) throws IOException {
        HttpGet request;
        try {
            URI uri = this.prepare(path);
            request = new HttpGet(uri);
        }
        catch (URISyntaxException e) {
            throw new IOException(e);
        }
        for (Header h : this.extraHeaders) {
            request.addHeader(h);
        }
        request.addHeader("User-Agent", "Day cq-packageshare-client");
        request.setConfig(RequestConfig.custom().setRedirectsEnabled(this.followRedirects).build());
        HttpClientContext context = HttpClientContext.create();
        if (this.credentials != null) {
            BasicCredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(AuthScope.ANY, this.credentials);
            context.setCredentialsProvider((CredentialsProvider)credsProvider);
            BasicAuthCache authCache = new BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            authCache.put(this.targetHost, (AuthScheme)basicAuth);
            context.setAuthCache((AuthCache)authCache);
        }
        this.response = this.httpClient.execute((HttpUriRequest)request, (HttpContext)context);
        return this.postProcessResponse();
    }

    @Override
    public int doPost(String path) throws IOException {
        HttpPost request;
        try {
            URI uri = this.prepare(path);
            request = new HttpPost(uri);
        }
        catch (URISyntaxException e) {
            throw new IOException(e);
        }
        if (this.mpBuilder != null) {
            request.setEntity(this.mpBuilder.build());
        }
        for (Header h : this.extraHeaders) {
            request.addHeader(h);
        }
        request.addHeader("User-Agent", "Day cq-packageshare-client");
        HttpClientContext context = HttpClientContext.create();
        if (this.credentials != null) {
            BasicCredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(AuthScope.ANY, this.credentials);
            context.setCredentialsProvider((CredentialsProvider)credsProvider);
            BasicAuthCache authCache = new BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            authCache.put(this.targetHost, (AuthScheme)basicAuth);
            context.setAuthCache((AuthCache)authCache);
        }
        this.response = this.httpClient.execute((HttpUriRequest)request, (HttpContext)context);
        return this.postProcessResponse();
    }

    @Override
    public void close() {
        if (this.response != null) {
            try {
                this.response.close();
            }
            catch (IOException e) {
                log.error("error while closing response", (Throwable)e);
            }
        }
        this.response = null;
        this.mpBuilder = null;
    }

    @Override
    public boolean isHtml() {
        return this.contentType != null && this.contentType.startsWith("text/html");
    }

    @Override
    public String getContentType() {
        return this.contentType;
    }

    @Override
    public String getLastModified() {
        return this.lastModified;
    }

    @Override
    public void setLastModified(String lastModified) {
        this.lastModified = lastModified;
    }

    @Override
    public long getContentLength() {
        return this.response.getEntity().getContentLength();
    }

    @Override
    public String getLocation(boolean rewrite, boolean spool) {
        String location = this.getResponseHeaderValue("Location");
        if (location == null) {
            log.error("No location header in response.");
            return null;
        }
        if (rewrite) {
            if (!location.startsWith("/")) {
                log.error("Location must not be absolute url.");
                return null;
            }
            location = this.rewriteURL(location, spool);
        }
        return location;
    }

    @Override
    public Header getResponseHeader(String name) {
        return this.response.getFirstHeader(name);
    }

    @Override
    public String getResponseHeaderValue(String name) {
        Header header = this.getResponseHeader(name);
        return header == null ? null : header.getValue();
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public void rewrite(Writer writer) throws IOException {
        if (this.writer == null) {
            this.writer = writer;
        }
        InputStream in = this.response.getEntity().getContent();
        try {
            if (in != null) {
                this.rewriteHtml(in);
            }
        }
        finally {
            IOUtils.closeQuietly((InputStream)in);
            this.close();
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public int spool(OutputStream out) throws IOException {
        InputStream in = this.response.getEntity().getContent();
        try {
            if (in != null) {
                int n;
                long len = this.response.getEntity().getContentLength();
                byte[] buffer = new byte[8192];
                long count = 0;
                while (-1 != (n = in.read(buffer))) {
                    out.write(buffer, 0, n);
                    count += (long)n;
                    if (this.tracker == null) continue;
                    this.tracker.onProgress(count, len);
                }
                int n2 = (int)count;
                return n2;
            }
            int len = -1;
            return len;
        }
        finally {
            IOUtils.closeQuietly((InputStream)in);
            this.close();
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public String fetch() throws IOException {
        try {
            Header hdr = this.response.getEntity().getContentEncoding();
            String encoding = hdr == null ? null : hdr.getValue();
            String string = IOUtils.toString((InputStream)this.response.getEntity().getContent(), (String)(encoding == null ? "utf-8" : encoding));
            return string;
        }
        finally {
            this.close();
        }
    }

    public class BinaryInputStream
    extends InputStream {
        private final Binary data;
        private InputStream delegatee;

        public BinaryInputStream(Binary data) {
            this.data = data;
        }

        @Override
        public int read() throws IOException {
            return this.getInputStream().read();
        }

        @Override
        public int read(byte[] b) throws IOException {
            return this.getInputStream().read(b);
        }

        @Override
        public int read(byte[] b, int off, int len) throws IOException {
            return this.getInputStream().read(b, off, len);
        }

        @Override
        public long skip(long n) throws IOException {
            return this.getInputStream().skip(n);
        }

        @Override
        public int available() throws IOException {
            return this.getInputStream().available();
        }

        @Override
        public void close() throws IOException {
            this.getInputStream().close();
        }

        public long getLength() {
            try {
                return this.data.getSize();
            }
            catch (RepositoryException e) {
                return -1;
            }
        }

        private InputStream getInputStream() throws IOException {
            if (this.delegatee == null) {
                try {
                    this.delegatee = this.data.getStream();
                    if (ProxyImpl.this.tracker != null) {
                        this.delegatee = new TrackingInputStream(this.delegatee, this.getLength(), ProxyImpl.this.tracker);
                    }
                }
                catch (RepositoryException e) {
                    throw new IOException("Error while retrieving string", (Throwable)e);
                }
            }
            return this.delegatee;
        }
    }

}